Add CI benchmark workflow with dask backends and regression detection

- Add dask backend to benchmark helpers and 5 focus modules (slope,
  proximity, zonal, focal, cost_distance)
- Add CI workflow that runs ASV benchmarks on PRs labeled 'performance'
  and on pushes to master, failing on >20% regression
- Add auto-labeler to tag PRs touching xrspatial source with
  'performance' label
- Add dask to ASV dependency matrix

Author: brendancol

.github/labeler.yml

@@ -0,0 +1,6 @@
+performance:
+  - changed-files:
+    - any-glob-to-any-file:
+      - 'xrspatial/*.py'
+      - 'xrspatial/**/*.py'
+      - '!xrspatial/tests/**'

.github/workflows/benchmarks.yml

@@ -0,0 +1,67 @@
+name: Benchmarks
+
+on:
+  pull_request:
+    types: [labeled]
+  push:
+    branches: [master]
+
+env:
+  ASV_FACTOR: "1.2"
+
+jobs:
+  benchmarks:
+    if: >
+      (github.event_name == 'push') ||
+      (github.event_name == 'pull_request' && github.event.label.name == 'performance')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install ASV and virtualenv
+        run: pip install asv virtualenv
+
+      - name: Configure ASV machine
+        working-directory: benchmarks
+        run: asv machine --yes
+
+      - name: Run benchmarks (PR)
+        if: github.event_name == 'pull_request'
+        working-directory: benchmarks
+        run: |
+          asv continuous origin/master HEAD \
+            --factor $ASV_FACTOR \
+            --bench "^(Slope|Proximity|Zonal|CostDistance|Focal)" \
+            | tee bench_output.txt
+
+      - name: Run benchmarks (push to master)
+        if: github.event_name == 'push'
+        working-directory: benchmarks
+        run: |
+          asv run HEAD^! \
+            --bench "^(Slope|Proximity|Zonal|CostDistance|Focal)" \
+            | tee bench_output.txt
+
+      - name: Check for regressions
+        working-directory: benchmarks
+        run: |
+          if grep -q "REGRESSION" bench_output.txt; then
+            echo "::error::Performance regression detected (>${ASV_FACTOR}x slower)"
+            cat bench_output.txt
+            exit 1
+          fi
+
+      - name: Upload benchmark results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: benchmark-results
+          path: |
+            benchmarks/bench_output.txt
+            benchmarks/.asv/results/

.github/workflows/labeler.yml

@@ -0,0 +1,14 @@
+name: Label PRs
+
+on:
+  pull_request_target:
+    types: [opened, synchronize]
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/labeler@v5

benchmarks/asv.conf.json

@@ -72,6 +72,7 @@
     //
     "matrix": {
         "pyct": [],
+        "dask": [],
         // Optional for cupy support; use correct cuda version.
         //"cupy-cuda113": [],
         // Optional for ray-tracing support, need cupy too.

benchmarks/benchmarks/common.py

@@ -55,14 +55,17 @@ def get_xr_dataarray(
             raise NotImplementedError()
         import cupy
         z = cupy.asarray(z)
+    elif type == "dask":
+        import dask.array as da
+        z = da.from_array(z, chunks=(max(1, ny // 2), max(1, nx // 2)))
     else:
         raise RuntimeError(f"Unrecognised type {type}")
 
     return xr.DataArray(z, coords=dict(y=y, x=x), dims=["y", "x"])
 
 
 class Benchmarking:
-    params = ([100, 300, 1000, 3000, 10000], ["numpy", "cupy"])
+    params = ([100, 300, 1000, 3000, 10000], ["numpy", "cupy", "dask"])
     param_names = ("nx", "type")
 
     def __init__(self, func=None):

benchmarks/benchmarks/cost_distance.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+from xrspatial.cost_distance import cost_distance
+
+from .common import get_xr_dataarray
+
+
+class CostDistance:
+    params = ([100, 300, 1000], ["numpy", "dask"])
+    param_names = ("nx", "type")
+
+    def setup(self, nx, type):
+        ny = nx // 2
+        self.agg = get_xr_dataarray((ny, nx), type, is_int=True)
+        friction = get_xr_dataarray((ny, nx), type)
+        # Ensure positive friction values
+        if type == "dask":
+            import dask.array as da
+            friction.data = da.fabs(friction.data) + 0.1
+        else:
+            friction.data = np.abs(friction.data) + 0.1
+        self.friction = friction
+
+    def time_cost_distance(self, nx, type):
+        cost_distance(self.agg, self.friction)

benchmarks/benchmarks/focal.py

@@ -7,7 +7,7 @@
 
 
 class Focal:
-    params = ([100, 300, 1000, 3000], [(5, 5), (25, 25)], ["numpy", "cupy"])
+    params = ([100, 300, 1000, 3000], [(5, 5), (25, 25)], ["numpy", "cupy", "dask"])
     param_names = ("nx", "kernelsize", "type")
 
     def setup(self, nx, kernelsize, type):
@@ -18,7 +18,7 @@ def setup(self, nx, kernelsize, type):
 
 
 class FocalApply(Focal):
-    params = ([100, 300, 1000, 3000], [(5, 5), (25, 25)], ["numpy"])
+    params = ([100, 300, 1000, 3000], [(5, 5), (25, 25)], ["numpy", "dask"])
 
     def time_apply(self, nx, kernelsize, type):
         apply(self.agg, self.kernel)
@@ -30,14 +30,14 @@ def time_hotspots(self, nx, kernelsize, type):
 
 
 class FocalStats(Focal):
-    params = ([100, 300, 1000, 3000], [(5, 5), (15, 15)], ["numpy", "cupy"])
+    params = ([100, 300, 1000, 3000], [(5, 5), (15, 15)], ["numpy", "cupy", "dask"])
 
     def time_focal_stats(self, nx, kernelsize, type):
         focal_stats(self.agg, self.kernel)
 
 
 class FocalMean:
-    params = ([100, 300, 1000, 3000, 10000], [1, 10], ["numpy", "cupy"])
+    params = ([100, 300, 1000, 3000, 10000], [1, 10], ["numpy", "cupy", "dask"])
     param_names = ("nx", "passes", "type")
 
     def setup(self, nx, passes, type):

benchmarks/benchmarks/proximity.py

@@ -10,7 +10,7 @@ class Base:
         [100, 1000],
         [1, 10, 100],
         ["EUCLIDEAN", "GREAT_CIRCLE", "MANHATTAN"],
-        ["numpy"]
+        ["numpy", "dask"]
     )
     param_names = ("nx", "n_target_values", "distance_metric", "type")
 

benchmarks/benchmarks/zonal.py

@@ -27,7 +27,7 @@ def create_arr(data=None, H=10, W=10, backend='numpy'):
 class Zonal:
     # Note that rtxpy hillshade includes shadow calculations so timings are
     # not comparable with numpy and cupy hillshade.
-    params = ([400, 1600, 3200], [2, 4, 8], ["numpy", "cupy"])
+    params = ([400, 1600, 3200], [2, 4, 8], ["numpy", "cupy", "dask"])
     param_names = ("raster_dim", "zone_dim", "backend")
 
     def setup(self, raster_dim, zone_dim, backend):
@@ -64,7 +64,22 @@ def setup(self, raster_dim, zone_dim, backend):
         self.zones = create_arr(zones, backend=backend)
 
         # Now setup the custom stat funcs
-        if backend == 'cupy':
+        if backend == 'dask':
+            from xrspatial.utils import ngjit
+
+            @ngjit
+            def l2normKernel(arr):
+                acc = 0
+                for x in arr:
+                    acc += x * x
+                return np.sqrt(acc)
+
+            self.custom_stats = {
+                'double_sum': lambda val: val.sum()*2,
+                'l2norm': lambda val: np.sqrt(np.sum(val * val)),
+                'l2normKernel': lambda val: l2normKernel(val)
+            }
+        elif backend == 'cupy':
             import cupy
             l2normKernel = cupy.ReductionKernel(
                 in_params='T x', out_params='float64 y',