benchmarks/README.md

 # FINAM benchmarks
 
+## SDK
+
+### Push & pull
+
+Push & pull using numpy arrays
+
+![tools](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-sdk-io.svg?job=benchmark)
+
 ## Data
 
 ### Tools
 
+Functions in `data/tools`
+
 ![tools](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-data-tools.svg?job=benchmark)
+
+Functions in `data/tools` with longer run time
+
+![tools-slow](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-data-tools-slow.svg?job=benchmark)
+
+### Grids
+
+Grid creation
+
+![create-grids](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-data-create-grids.svg?job=benchmark)
+
+Grid functions
+
+![grid-functions](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-data-grid-functions.svg?job=benchmark)
+
+Grid functions with longer run time
+
+![grid-functions-slow](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-data-grid-functions-slow.svg?job=benchmark)
+
+## Adapters
+
+### Regridding
+
+Regridding adapters, dependent on grid size.
+
+Regridding from a uniform grid to another uniform grid of the same size, with slightly offset origin.
+
+For more performant regridding, see the
+[ESMPy](https://earthsystemmodeling.org/esmpy/)-based regridding adapter in
+[`finam-regrid`](https://git.ufz.de/FINAM/finam-regrid/)
+([benchmarks](https://git.ufz.de/FINAM/finam-regrid/-/tree/main/benchmarks))
+
+![adapters-regrid](https://git.ufz.de/FINAM/finam/-/jobs/artifacts/main/raw/bench/bench-adapters-regrid.svg?job=benchmark)

benchmarks/adapters/test_regrid.py

+import datetime as dt
+import unittest
+
+import pytest
+
+import finam as fm
+
+
+class TestRegrid(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def setupBenchmark(self, benchmark):
+        self.benchmark = benchmark
+
+    def setup_adapter(self, grid1, grid2, adapter):
+        time = dt.datetime(2000, 1, 1)
+        self.data = fm.data.full(1.0, "test", fm.Info(time=time, grid=grid1), time=time)
+
+        self.source = fm.modules.CallbackGenerator(
+            callbacks={"Step": (lambda t: self.data, fm.Info(None, grid=grid1))},
+            start=time,
+            step=dt.timedelta(1.0),
+        )
+        self.adapter = adapter
+        self.source.initialize()
+        self.source.outputs["Step"] >> self.adapter
+
+        self.adapter.get_info(fm.Info(None, grid=grid2))
+        self.source.connect()
+        self.source.connect()
+        self.source.validate()
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_nearest_01_32x16(self):
+        grid1 = fm.UniformGrid((32, 16))
+        grid2 = fm.UniformGrid((32, 16), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridNearest())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_nearest_02_512x256(self):
+        grid1 = fm.UniformGrid((512, 256))
+        grid2 = fm.UniformGrid((512, 256), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridNearest())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_nearest_03_1024x512(self):
+        grid1 = fm.UniformGrid((1024, 512))
+        grid2 = fm.UniformGrid((1024, 512), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridNearest())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_nearest_04_2048x1024(self):
+        grid1 = fm.UniformGrid((2048, 1024))
+        grid2 = fm.UniformGrid((2048, 1024), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridNearest())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_linear_01_32x16(self):
+        grid1 = fm.UniformGrid((32, 16))
+        grid2 = fm.UniformGrid((32, 16), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridLinear())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_linear_02_512x256(self):
+        grid1 = fm.UniformGrid((512, 256))
+        grid2 = fm.UniformGrid((512, 256), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridLinear())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_linear_03_1024x512(self):
+        grid1 = fm.UniformGrid((1024, 512))
+        grid2 = fm.UniformGrid((1024, 512), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridLinear())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )
+
+    @pytest.mark.benchmark(group="adapters-regrid")
+    def test_regrid_linear_04_2048x1024(self):
+        grid1 = fm.UniformGrid((2048, 1024))
+        grid2 = fm.UniformGrid((2048, 1024), origin=(0.25, 0.25))
+
+        self.setup_adapter(grid1, grid2, fm.adapters.RegridLinear())
+        _result = self.benchmark(
+            self.adapter.get_data, time=dt.datetime(2000, 1, 1), target=None
+        )

benchmarks/data/test_grids.py

+import unittest
+
+import numpy as np
+import pytest
+
+import finam as fm
+
+
+class TestCreateUniform(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def setupBenchmark(self, benchmark):
+        self.benchmark = benchmark
+
+    def create_grid(self, size):
+        return fm.UniformGrid(size)
+
+    @pytest.mark.benchmark(group="data-create-grids")
+    def test_create_uniform_01_2x1(self):
+        _result = self.benchmark(self.create_grid, size=(2, 1))
+
+    @pytest.mark.benchmark(group="data-create-grids")
+    def test_create_uniform_02_512x256(self):
+        _result = self.benchmark(self.create_grid, size=(512, 256))
+
+    @pytest.mark.benchmark(group="data-create-grids")
+    def test_create_uniform_03_2048x1024(self):
+        _result = self.benchmark(self.create_grid, size=(2048, 1024))
+
+
+class TestCreateRectilinear(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def setupBenchmark(self, benchmark):
+        self.benchmark = benchmark
+
+    def create_grid(self, axes):
+        return fm.RectilinearGrid(axes)
+
+    @pytest.mark.benchmark(group="data-create-grids")
+    def test_create_rectilinear_01_2x1(self):
+        axes = [np.asarray(range(2)), np.asarray(range(1))]
+        _result = self.benchmark(self.create_grid, axes=axes)
+
+    @pytest.mark.benchmark(group="data-create-grids")
+    def test_create_rectilinear_02_512x256(self):
+        axes = [np.asarray(range(512)), np.asarray(range(256))]
+        _result = self.benchmark(self.create_grid, axes=axes)
+
+    @pytest.mark.benchmark(group="data-create-grids")
+    def test_create_rectilinear_03_2048x1024(self):
+        axes = [np.asarray(range(2048)), np.asarray(range(1024))]
+        _result = self.benchmark(self.create_grid, axes=axes)
+
+
+class TestGridFunctionsSimple(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def setupBenchmark(self, benchmark):
+        self.benchmark = benchmark
+
+    def get_cell_axes(self, grid):
+        return grid.cell_axes
+
+    @pytest.mark.benchmark(group="data-grid-functions")
+    def test_cell_axes_01_2x1(self):
+        grid = fm.UniformGrid((2, 1))
+        _result = self.benchmark(self.get_cell_axes, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions")
+    def test_cell_axes_02_512x256(self):
+        grid = fm.UniformGrid((512, 256))
+        _result = self.benchmark(self.get_cell_axes, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions")
+    def test_cell_axes_03_2048x1024(self):
+        grid = fm.UniformGrid((2048, 1024))
+        _result = self.benchmark(self.get_cell_axes, grid=grid)
+
+
+class TestGridFunctionsSlow(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def setupBenchmark(self, benchmark):
+        self.benchmark = benchmark
+
+    def get_points(self, grid):
+        return grid.points
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_points_01_2x1(self):
+        grid = fm.UniformGrid((2, 1))
+        _result = self.benchmark(self.get_points, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_points_02_512x256(self):
+        grid = fm.UniformGrid((512, 256))
+        _result = self.benchmark(self.get_points, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_points_03_2048x1024(self):
+        grid = fm.UniformGrid((2048, 1024))
+        _result = self.benchmark(self.get_points, grid=grid)
+
+    def get_cell_centers(self, grid):
+        return grid.cell_centers
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_cell_centers_01_2x1(self):
+        grid = fm.UniformGrid((2, 1))
+        _result = self.benchmark(self.get_cell_centers, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_cell_centers_02_512x256(self):
+        grid = fm.UniformGrid((512, 256))
+        _result = self.benchmark(self.get_cell_centers, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_cell_centers_03_2048x1024(self):
+        grid = fm.UniformGrid((2048, 1024))
+        _result = self.benchmark(self.get_cell_centers, grid=grid)
+
+    def get_cells(self, grid):
+        return grid.cells
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_cells_01_2x1(self):
+        grid = fm.UniformGrid((2, 1))
+        _result = self.benchmark(self.get_cells, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_cells_02_512x256(self):
+        grid = fm.UniformGrid((512, 256))
+        _result = self.benchmark(self.get_cells, grid=grid)
+
+    @pytest.mark.benchmark(group="data-grid-functions-slow")
+    def test_cells_03_2048x1024(self):
+        grid = fm.UniformGrid((2048, 1024))
+        _result = self.benchmark(self.get_cells, grid=grid)

benchmarks/data/test_tools.py

@@ -81,19 +81,19 @@ class TestFull(unittest.TestCase):
     def setupBenchmark(self, benchmark):
         self.benchmark = benchmark
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_full_01_2x1(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((2, 1)), units="m")
         _result = self.benchmark(full, value=0.0, name="test", info=info, time=time)
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_full_02_512x256(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((512, 256)), units="m")
         _result = self.benchmark(full, value=0.0, name="test", info=info, time=time)
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_full_03_2048x1024(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
@@ -105,21 +105,21 @@ class TestFullLike(unittest.TestCase):
     def setupBenchmark(self, benchmark):
         self.benchmark = benchmark
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_full_like_01_2x1(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((2, 1)), units="m")
         xdata = full(0.0, "test", info, time)
         _result = self.benchmark(full_like, xdata=xdata, value=0.0)
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_full_like_02_512x256(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((512, 256)), units="m")
         xdata = full(0.0, "test", info, time)
         _result = self.benchmark(full_like, xdata=xdata, value=0.0)
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_full_like_03_2048x1024(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
@@ -181,21 +181,21 @@ class TestUnitsTools(unittest.TestCase):
         xdata = full(0.0, "test", info, time)
         _result = self.benchmark(get_units, xdata=xdata)
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_to_units_01_2x1(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((2, 1)), units="m")
         xdata = full(0.0, "test", info, time)
         _result = self.benchmark(to_units, xdata=xdata, units="in")
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_to_units_02_512x256(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((512, 256)), units="m")
         xdata = full(0.0, "test", info, time)
         _result = self.benchmark(to_units, xdata=xdata, units="in")
 
-    @pytest.mark.benchmark(group="data-tools")
+    @pytest.mark.benchmark(group="data-tools-slow")
     def test_to_units_03_2048x1024(self):
         time = dt.datetime(2000, 1, 1)
         info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")

benchmarks/sdk/test_io.py

+import datetime as dt
+import unittest
+
+import pytest
+
+import finam as fm
+
+
+class TestPushPull(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def setupBenchmark(self, benchmark):
+        self.benchmark = benchmark
+
+    def push_pull(self):
+        self.out.push_data(self.data, self.time)
+        _ = self.inp.pull_data(self.time)
+        self.time += dt.timedelta(days=1)
+
+    def setup_link(self, grid):
+        self.time = dt.datetime(2000, 1, 1)
+        info = fm.Info(time=self.time, grid=grid, units="m")
+        self.data = fm.data.strip_data(fm.data.full(0.0, "test", info, self.time))
+
+        self.out = fm.Output(name="Output")
+        self.inp = fm.Input(name="Input")
+
+        self.out >> self.inp
+        self.inp.ping()
+        self.out.push_info(info)
+        self.inp.exchange_info(info)
+
+    @pytest.mark.benchmark(group="sdk-io")
+    def test_push_pull_np_01_2x1(self):
+        grid = fm.UniformGrid((2, 1))
+        self.setup_link(grid)
+        self.benchmark(self.push_pull)
+
+    @pytest.mark.benchmark(group="sdk-io")
+    def test_push_pull_np_02_512x256(self):
+        grid = fm.UniformGrid((512, 256))
+        self.setup_link(grid)
+        self.benchmark(self.push_pull)
+
+    @pytest.mark.benchmark(group="sdk-io")
+    def test_push_pull_np_03_2048x1024(self):
+        grid = fm.UniformGrid((2048, 1024))
+        self.setup_link(grid)
+        self.benchmark(self.push_pull)