[PATCH] Fix race conditions during the setup of logical decoding.

agora inbox for [email protected]  
help / color / mirror / Atom feed

[PATCH] Fix race conditions during the setup of logical decoding.
227+ messages / 2 participants
[nested] [flat]

* [PATCH] Fix race conditions during the setup of logical decoding.
@ 2026-01-19 15:07 Antonin Houska <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Antonin Houska @ 2026-01-19 15:07 UTC (permalink / raw)

Although it's rather unlikely, it can happen that the snapshot builder
considers transaction committed (according to WAL) before the commit could be
recorded in CLOG. In an extreme case, snapshot can even be created and used in
between. Since both snapshot and CLOG are needed for visibility checks, this
inconsistency can make them work incorrectly.

The typical symptom is that a transaction that the snapshot considers not
running anymore is (per CLOG) considered aborted instead of committed. Thus a
new tuple version can be evaluated as invisible (if xmin is incorrectly
considered aborted) or a deleted tuple version can be evaluated as visible (if
xmax is incorrectly considered aborted).

This patch fixes the problem by checking if all the XIDs that the new snapshot
considers committed are really committed per CLOG. If at least one is not, the
check is repeated after a short delay. However, a single check is sufficient
in almost all cases, so the performance impact should be minimal.
---
 src/backend/replication/logical/snapbuild.c   | 41 +++++++++++++++++++
 .../utils/activity/wait_event_names.txt       |  1 +
 2 files changed, 42 insertions(+)

diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
index 9b09dc8eac1..c02d08f3417 100644
--- a/src/backend/replication/logical/snapbuild.c
+++ b/src/backend/replication/logical/snapbuild.c
@@ -400,6 +400,47 @@ SnapBuildBuildSnapshot(SnapBuild *builder)
 	snapshot->xmin = builder->xmin;
 	snapshot->xmax = builder->xmax;
 
+	/*
+	 * Although it's very unlikely, it's possible that a commit WAL record was
+	 * decoded but CLOG is not aware of the commit yet. Should the CLOG update
+	 * be delayed even more, visibility checks that use this snapshot could
+	 * work incorrectly. Therefore we check the CLOG status here.
+	 */
+	while (true)
+	{
+		bool	found = false;
+
+		for (int i = 0; i < builder->committed.xcnt; i++)
+		{
+			/*
+			 * XXX Is it worth remembering the XIDs that appear to be
+			 * committed per CLOG and skipping them in the next iteration of
+			 * the outer loop? Not sure it's worth the effort - a single
+			 * iteration is enough in most cases.
+			 */
+			if (unlikely(!TransactionIdDidCommit(builder->committed.xip[i])))
+			{
+				found = true;
+
+				/*
+				 * Wait a bit before going to the next iteration of the outer
+				 * loop. The race conditions we address here is pretty rare,
+				 * so we shouldn't need to wait too long.
+				 */
+				(void) WaitLatch(MyLatch,
+								 WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
+								 10L,
+								 WAIT_EVENT_SNAPBUILD_CLOG);
+				ResetLatch(MyLatch);
+
+				break;
+			}
+		}
+
+		if (!found)
+			break;
+	}
+
 	/* store all transactions to be treated as committed by this snapshot */
 	snapshot->xip =
 		(TransactionId *) ((char *) snapshot + sizeof(SnapshotData));
diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt
index 5537a2d2530..b6318b0cf37 100644
--- a/src/backend/utils/activity/wait_event_names.txt
+++ b/src/backend/utils/activity/wait_event_names.txt
@@ -181,6 +181,7 @@ PG_SLEEP	"Waiting due to a call to <function>pg_sleep</function> or a sibling fu
 RECOVERY_APPLY_DELAY	"Waiting to apply WAL during recovery because of a delay setting."
 RECOVERY_RETRIEVE_RETRY_INTERVAL	"Waiting during recovery when WAL data is not available from any source (<filename>pg_wal</filename>, archive or stream)."
 REGISTER_SYNC_REQUEST	"Waiting while sending synchronization requests to the checkpointer, because the request queue is full."
+SNAPBUILD_CLOG	"Waiting for CLOG update before building snapshot."
 SPIN_DELAY	"Waiting while acquiring a contended spinlock."
 VACUUM_DELAY	"Waiting in a cost-based vacuum delay point."
 VACUUM_TRUNCATE	"Waiting to acquire an exclusive lock to truncate off any empty pages at the end of a table vacuumed."
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

* [PATCH v12a 3/3] ci: macports improvements
@ 2026-06-04 14:17 Andres Freund <[email protected]>
  0 siblings, 0 replies; 227+ messages in thread

From: Andres Freund @ 2026-06-04 14:17 UTC (permalink / raw)

I realized two things:

1) We should save the macports cache before building & running tests, we don't
   want to again start from scratch if the task failed or was cancelled

2) We should use a partial cache match, as it's much faster to start from
   that, than from scratch.

This requires some additional complexity, we now need an explicit restore step
and need to check if the install step succeeded. But it's a very substantial
improvement in runtime, so it's worthwhile.
---
 .github/workflows/pg-ci.yml | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml
index dea8d95d729..dd4ff4c91d3 100644
--- a/.github/workflows/pg-ci.yml
+++ b/.github/workflows/pg-ci.yml
@@ -690,18 +690,23 @@ jobs:
           sudo sysctl kern.corefile="$HOME/cores/core.%P"
 
       - name: "Macports: Compute cache key"
-        id: mpkey
+        id: mp-key
         run: |
           macos_major=$(sw_vers -productVersion | sed 's/\..*//')
           pkglist_hash=$(printf '%s' "$MACOS_PACKAGE_LIST" | md5 -q)
           script_hash=$(md5 -q src/tools/ci/ci_macports_packages.sh)
           echo "key=macports-${macos_major}-${pkglist_hash}-${script_hash}" >> "$GITHUB_OUTPUT"
+          # It's faster to start with a partial cache for the same macos
+          # version than from scratch
+          echo "restore-key=macports-${macos_major}-" >> "$GITHUB_OUTPUT"
 
       - name: "MacPorts: Restore cache"
-        uses: actions/cache@v5
+        id: mp-restore
+        uses: actions/cache/restore@v5
         with:
           path: ${{ env.MACPORTS_CACHE }}
-          key: ${{ steps.mpkey.outputs.key }}
+          key: ${{ steps.mp-key.outputs.key }}
+          restore-keys: ${{ steps.mp-key.outputs.restore-key }}
 
       # Use MacPorts, even though Homebrew is installed. The installation
       # of the additional packages we need would take quite a while with
@@ -714,6 +719,7 @@ jobs:
       # actually p5.34-io-tty. Using the unversioned name works, but
       # updates MacPorts every time.
       - name: "MacPorts: Install dependencies"
+        id: mp-install
         env:
           # Pass token so the script's GitHub API call to list MacPorts
           # releases isn't subject to the 60/h/IP unauthenticated rate
@@ -727,6 +733,18 @@ jobs:
           echo /opt/local/sbin >> "$GITHUB_PATH"
           echo /opt/local/bin >> "$GITHUB_PATH"
 
+      # Save macports before running build / tests, creating macports can be
+      # quite slow, so we don't want to start from scratch in the next run.
+      - name: "MacPorts: Save cache"
+        uses: actions/cache/save@v5
+        # Don't save cache if we had an exact match
+        if: |
+          steps.mp-install.conclusion == 'success' &&
+          steps.mp-restore.outputs.cache-hit != 'true'
+        with:
+          path: ${{ env.MACPORTS_CACHE }}
+          key: ${{ steps.mp-key.outputs.key }}
+
       - name: Configure
         env:
           PKG_CONFIG_PATH: /opt/local/lib/pkgconfig/
-- 
2.54.0.380.gc69baaf57b


--ijwec7zgt2lxep65--





^ permalink  raw  reply  [nested|flat] 227+ messages in thread

end of thread, other threads:[~2026-06-04 14:17 UTC | newest]

Thread overview: 227+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2026-01-19 15:07 [PATCH] Fix race conditions during the setup of logical decoding. Antonin Houska <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>
2026-06-04 14:17 [PATCH v12a 3/3] ci: macports improvements Andres Freund <[email protected]>

This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox