diff --git a/benchmarks/adapters/test_regrid.py b/benchmarks/adapters/test_regrid.py
index ecb5add2d98572cf214d5cc7eb93610aecc7ee33..e35bb9f2213af78a1ef17b992f7b5d30a7b23352 100644
--- a/benchmarks/adapters/test_regrid.py
+++ b/benchmarks/adapters/test_regrid.py
@@ -13,7 +13,7 @@ class TestRegrid(unittest.TestCase):
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))
+ self.data = fm.data.full(1.0, fm.Info(time=time, grid=grid1))
self.source = fm.modules.CallbackGenerator(
callbacks={"Step": (lambda t: self.data, fm.Info(None, grid=grid1))},
diff --git a/benchmarks/data/test_tools.py b/benchmarks/data/test_tools.py
index 4bf066aa11f1ffefaed1d70d4d560834c23f6a00..dcb818b26527da8dfd18123b54a4395d35fb4570 100644
--- a/benchmarks/data/test_tools.py
+++ b/benchmarks/data/test_tools.py
@@ -29,15 +29,15 @@ class TestCheckXarray(unittest.TestCase):
def test_check_xarray_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)
- _result = self.benchmark(check, xdata=xdata, name="test", info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(check, xdata=xdata, info=info)
@pytest.mark.benchmark(group="data-tools")
def test_check_xarray_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)
- _result = self.benchmark(check, xdata=xdata, name="test", info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(check, xdata=xdata, info=info)
class TestToXarray(unittest.TestCase):
@@ -45,116 +45,57 @@ class TestToXarray(unittest.TestCase):
def setupBenchmark(self, benchmark):
self.benchmark = benchmark
- def copy_xarray_to_xarray(self, data, info):
- return to_xarray(data.copy(), name="data", info=info)
-
def copy_numpy_to_xarray(self, data, info):
- return to_xarray(np.copy(data), name="data", info=info)
+ return to_xarray(np.copy(data), info=info)
@pytest.mark.benchmark(group="data-tools")
def test_to_xarray_np_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)
- data = strip_data(xdata)
- _result = self.benchmark(to_xarray, data=data, name="test", info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(to_xarray, data=xdata, info=info)
@pytest.mark.benchmark(group="data-tools")
def test_to_xarray_np_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)
- data = strip_data(xdata)
- _result = self.benchmark(to_xarray, data=data, name="test", info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(to_xarray, data=xdata, info=info)
@pytest.mark.benchmark(group="data-tools")
def test_to_xarray_np_03_2048x1024(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
- xdata = full(0.0, "test", info)
- data = strip_data(xdata)
- _result = self.benchmark(to_xarray, data=data, name="test", info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(to_xarray, data=xdata, info=info)
@pytest.mark.benchmark(group="data-tools-slow")
def test_cp_to_xarray_np_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)
- data = strip_data(xdata)
- _result = self.benchmark(self.copy_numpy_to_xarray, data=data, info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(self.copy_numpy_to_xarray, data=xdata, info=info)
@pytest.mark.benchmark(group="data-tools-slow")
def test_cp_to_xarray_np_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)
- data = strip_data(xdata)
- _result = self.benchmark(self.copy_numpy_to_xarray, data=data, info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(self.copy_numpy_to_xarray, data=xdata, info=info)
@pytest.mark.benchmark(group="data-tools-slow")
def test_cp_to_xarray_np_03_1024x512(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((1024, 512)), units="m")
- xdata = full(0.0, "test", info)
- data = strip_data(xdata)
- _result = self.benchmark(self.copy_numpy_to_xarray, data=data, info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(self.copy_numpy_to_xarray, data=xdata, info=info)
@pytest.mark.benchmark(group="data-tools-slow")
def test_cp_to_xarray_np_04_2048x1024(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
- xdata = full(0.0, "test", info)
- data = strip_data(xdata)
- _result = self.benchmark(self.copy_numpy_to_xarray, data=data, info=info)
-
- @pytest.mark.benchmark(group="data-tools")
- def test_to_xarray_xr_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)
- _result = self.benchmark(to_xarray, data=xdata, name="test", info=info)
-
- @pytest.mark.benchmark(group="data-tools")
- def test_to_xarray_xr_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)
- _result = self.benchmark(to_xarray, data=xdata, name="test", info=info)
-
- @pytest.mark.benchmark(group="data-tools")
- def test_to_xarray_xr_03_2048x1024(self):
- time = dt.datetime(2000, 1, 1)
- info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
- xdata = full(0.0, "test", info)
- _result = self.benchmark(to_xarray, data=xdata, name="test", info=info)
-
- @pytest.mark.benchmark(group="data-tools-slow")
- def test_cp_to_xarray_xr_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)
- _result = self.benchmark(self.copy_xarray_to_xarray, data=xdata, info=info)
-
- @pytest.mark.benchmark(group="data-tools-slow")
- def test_cp_to_xarray_xr_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)
- _result = self.benchmark(self.copy_xarray_to_xarray, data=xdata, info=info)
-
- @pytest.mark.benchmark(group="data-tools-slow")
- def test_cp_to_xarray_xr_03_1024x512(self):
- time = dt.datetime(2000, 1, 1)
- info = fm.Info(time=time, grid=fm.UniformGrid((1024, 512)), units="m")
- xdata = full(0.0, "test", info)
- _result = self.benchmark(self.copy_xarray_to_xarray, data=xdata, info=info)
-
- @pytest.mark.benchmark(group="data-tools-slow")
- def test_cp_to_xarray_xr_04_2048x1024(self):
- time = dt.datetime(2000, 1, 1)
- info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
- xdata = full(0.0, "test", info)
- _result = self.benchmark(self.copy_xarray_to_xarray, data=xdata, info=info)
+ xdata = full(0.0, info)
+ _result = self.benchmark(self.copy_numpy_to_xarray, data=xdata, info=info)
class TestFull(unittest.TestCase):
@@ -166,19 +107,19 @@ class TestFull(unittest.TestCase):
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)
+ _result = self.benchmark(full, value=0.0, info=info)
@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)
+ _result = self.benchmark(full, value=0.0, info=info)
@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")
- _result = self.benchmark(full, value=0.0, name="test", info=info)
+ _result = self.benchmark(full, value=0.0, info=info)
class TestFullLike(unittest.TestCase):
@@ -190,21 +131,21 @@ class TestFullLike(unittest.TestCase):
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)
+ xdata = full(0.0, info)
_result = self.benchmark(full_like, xdata=xdata, value=0.0)
@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)
+ xdata = full(0.0, info)
_result = self.benchmark(full_like, xdata=xdata, value=0.0)
@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")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
_result = self.benchmark(full_like, xdata=xdata, value=0.0)
@@ -217,8 +158,8 @@ class TestTimeTools(unittest.TestCase):
def test_strip_time(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)
- _result = self.benchmark(strip_time, xdata=xdata)
+ xdata = full(0.0, info)
+ _result = self.benchmark(strip_time, xdata=xdata, grid=info.grid)
class TestUnitsTools(unittest.TestCase):
@@ -230,21 +171,21 @@ class TestUnitsTools(unittest.TestCase):
def test_get_units(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)
+ xdata = full(0.0, info)
_result = self.benchmark(get_units, xdata=xdata)
@pytest.mark.benchmark(group="data-tools")
def test_is_quantified(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)
+ xdata = full(0.0, info)
_result = self.benchmark(is_quantified, xdata=xdata)
@pytest.mark.benchmark(group="data-tools")
def test_equivalent_units_true(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2, 1)), units="mm")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
result = self.benchmark(equivalent_units, unit1=xdata, unit2="L/m^2")
self.assertTrue(result)
@@ -252,7 +193,7 @@ class TestUnitsTools(unittest.TestCase):
def test_equivalent_units_false(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2, 1)), units="mm")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
result = self.benchmark(equivalent_units, unit1=xdata, unit2="m")
self.assertFalse(result)
@@ -260,68 +201,68 @@ class TestUnitsTools(unittest.TestCase):
def test_compatible_units(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2, 1)), units="mm")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
_result = self.benchmark(compatible_units, unit1=xdata, unit2="km")
@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)
+ xdata = full(0.0, info)
_result = self.benchmark(to_units, xdata=xdata, units="in")
@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)
+ xdata = full(0.0, info)
_result = self.benchmark(to_units, xdata=xdata, units="in")
@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")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
_result = self.benchmark(to_units, xdata=xdata, units="in")
@pytest.mark.benchmark(group="data-tools")
def test_to_units_noop_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)
+ xdata = full(0.0, info)
_result = self.benchmark(to_units, xdata=xdata, units="m")
@pytest.mark.benchmark(group="data-tools")
def test_to_units_noop_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)
+ xdata = full(0.0, info)
_result = self.benchmark(to_units, xdata=xdata, units="m")
@pytest.mark.benchmark(group="data-tools")
def test_to_units_noop_03_2048x1024(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
_result = self.benchmark(to_units, xdata=xdata, units="m")
@pytest.mark.benchmark(group="data-tools")
def test_get_magnitude_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)
+ xdata = full(0.0, info)
_result = self.benchmark(get_magnitude, xdata=xdata)
@pytest.mark.benchmark(group="data-tools")
def test_get_magnitude_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)
+ xdata = full(0.0, info)
_result = self.benchmark(get_magnitude, xdata=xdata)
@pytest.mark.benchmark(group="data-tools")
def test_get_magnitude_03_2048x1024(self):
time = dt.datetime(2000, 1, 1)
info = fm.Info(time=time, grid=fm.UniformGrid((2048, 1024)), units="m")
- xdata = full(0.0, "test", info)
+ xdata = full(0.0, info)
_result = self.benchmark(get_magnitude, xdata=xdata)
diff --git a/benchmarks/profiling/simple_numpy.py b/benchmarks/profiling/simple_numpy.py
index 5e0f58d4912771cac317af2c7389a44dbda32a2c..6027e7d0e9bfe647b741e09af96025a8d3aa519e 100644
--- a/benchmarks/profiling/simple_numpy.py
+++ b/benchmarks/profiling/simple_numpy.py
@@ -25,8 +25,8 @@ def run_model():
info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
data = [
- fm.data.strip_data(fm.data.full(0.0, "input", info1)),
- fm.data.strip_data(fm.data.full(0.0, "input", info1)),
+ fm.data.full(0.0, info1),
+ fm.data.full(0.0, info1),
]
def gen_data(t):
diff --git a/benchmarks/profiling/simple_xarray.py b/benchmarks/profiling/simple_xarray.py
deleted file mode 100644
index 23ed62b87706eb6d055e315b16ca81569b43e252..0000000000000000000000000000000000000000
--- a/benchmarks/profiling/simple_xarray.py
+++ /dev/null
@@ -1,73 +0,0 @@
-"""Simple coupling setup for profiling.
-
-Two components, coupled via a single link.
-
-Simulation runs for 1 year with a daily step in both components.
-Components exchange a 128x64 uniform grid.
-"""
-import cProfile
-import datetime as dt
-import io
-import pstats
-import sys
-
-import finam as fm
-
-
-def run_model():
- start_time = dt.datetime(2000, 1, 1)
- end_time = dt.datetime(2000, 12, 31)
-
- counter = 0
-
- size = (128, 64)
-
- info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
- info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
- data = [
- fm.data.full(0.0, "input", info1),
- fm.data.full(0.0, "input", info1),
- ]
-
- def gen_data(t):
- nonlocal counter
- d = data[counter % 2]
- counter += 1
- return d
-
- source = fm.modules.CallbackGenerator(
- callbacks={"Out": (gen_data, info1.copy())},
- start=start_time,
- step=dt.timedelta(days=1),
- )
- sink = fm.modules.DebugConsumer(
- inputs={
- "In": info2.copy(),
- },
- start=start_time,
- step=dt.timedelta(days=1),
- )
-
- composition = fm.Composition([source, sink])
- composition.initialize()
-
- source["Out"] >> sink["In"]
-
- composition.run(end_time=end_time)
-
-
-def run_model_multi(n):
- for _ in range(n):
- run_model()
-
-
-if __name__ == "__main__":
- pr = cProfile.Profile()
- pr.enable()
-
- run_model_multi(10)
-
- pr.disable()
- s = io.StringIO()
- ps = pstats.Stats(pr, stream=s).sort_stats(pstats.SortKey.CUMULATIVE)
- ps.dump_stats(sys.argv[1])
diff --git a/benchmarks/run/test_run.py b/benchmarks/run/test_run.py
index ebba97ae786c747c9b23ff4ce8b8f8225912ca65..26c56b1df094208a8f2d218a25d41397938f6295 100644
--- a/benchmarks/run/test_run.py
+++ b/benchmarks/run/test_run.py
@@ -19,16 +19,11 @@ class SimpleRunBase(unittest.TestCase):
self.counter += 1
return d
- def gen_data_copy_numpy(self, t):
+ def gen_data_copy(self, t):
d = self.data[self.counter % 2]
self.counter += 1
return np.copy(d)
- def gen_data_copy_xarray(self, t):
- d = self.data[self.counter % 2]
- self.counter += 1
- return d.copy()
-
def run_simulation(self, gen_func):
source = fm.modules.CallbackGenerator(
callbacks={"Out": (gen_func, self.info1.copy())},
@@ -64,8 +59,8 @@ class TestSimpleRun(SimpleRunBase):
self.info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
self.info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
self.data = [
- fm.data.full(0.0, "input", self.info1),
- fm.data.full(0.0, "input", self.info1),
+ fm.data.full(0.0, self.info1),
+ fm.data.full(0.0, self.info1),
]
@pytest.mark.benchmark(group="run-sim")
@@ -110,8 +105,8 @@ class TestSimpleRunUnits(SimpleRunBase):
self.info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
self.info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="km")
self.data = [
- fm.data.full(0.0, "input", self.info1),
- fm.data.full(0.0, "input", self.info1),
+ fm.data.full(0.0, self.info1),
+ fm.data.full(0.0, self.info1),
]
@pytest.mark.benchmark(group="run-sim")
@@ -147,52 +142,6 @@ class TestSimpleRunUnits(SimpleRunBase):
self.run_test(2048, 1024, self.gen_data)
-class TestSimpleRunNumpy(SimpleRunBase):
- @pytest.fixture(autouse=True)
- def setupBenchmark(self, benchmark):
- self.setup(benchmark)
-
- def setup_data(self, size):
- self.info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
- self.info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
- self.data = [
- fm.data.strip_data(fm.data.full(0.0, "input", self.info1)),
- fm.data.strip_data(fm.data.full(0.0, "input", self.info1)),
- ]
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_01_2x1(self):
- self.run_test(2, 1, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_02_32x16(self):
- self.run_test(32, 16, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_03_64x32(self):
- self.run_test(64, 32, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_04_128x64(self):
- self.run_test(128, 64, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_05_256x128(self):
- self.run_test(256, 128, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_06_512x256(self):
- self.run_test(512, 256, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_07_1024x512(self):
- self.run_test(1024, 512, self.gen_data)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_08_2048x1024(self):
- self.run_test(2048, 1024, self.gen_data)
-
-
class TestSimpleRunCopy(SimpleRunBase):
@pytest.fixture(autouse=True)
def setupBenchmark(self, benchmark):
@@ -202,84 +151,38 @@ class TestSimpleRunCopy(SimpleRunBase):
self.info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
self.info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
self.data = [
- fm.data.full(0.0, "input", self.info1),
- fm.data.full(0.0, "input", self.info1),
+ fm.data.full(0.0, self.info1),
+ fm.data.full(0.0, self.info1),
]
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_01_2x1(self):
- self.run_test(2, 1, self.gen_data_copy_xarray)
+ self.run_test(2, 1, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_02_32x16(self):
- self.run_test(32, 16, self.gen_data_copy_xarray)
+ self.run_test(32, 16, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_03_64x32(self):
- self.run_test(64, 32, self.gen_data_copy_xarray)
+ self.run_test(64, 32, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_04_128x64(self):
- self.run_test(128, 64, self.gen_data_copy_xarray)
+ self.run_test(128, 64, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_05_256x128(self):
- self.run_test(256, 128, self.gen_data_copy_xarray)
+ self.run_test(256, 128, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_06_512x256(self):
- self.run_test(512, 256, self.gen_data_copy_xarray)
+ self.run_test(512, 256, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_07_1024x512(self):
- self.run_test(1024, 512, self.gen_data_copy_xarray)
+ self.run_test(1024, 512, self.gen_data_copy)
@pytest.mark.benchmark(group="run-sim")
def test_run_simple_cp_08_2048x1024(self):
- self.run_test(2048, 1024, self.gen_data_copy_xarray)
-
-
-class TestSimpleRunNumpyCopy(SimpleRunBase):
- @pytest.fixture(autouse=True)
- def setupBenchmark(self, benchmark):
- self.setup(benchmark)
-
- def setup_data(self, size):
- self.info1 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
- self.info2 = fm.Info(time=None, grid=fm.UniformGrid(size), units="m")
- self.data = [
- fm.data.strip_data(fm.data.full(0.0, "input", self.info1)),
- fm.data.strip_data(fm.data.full(0.0, "input", self.info1)),
- ]
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_01_2x1(self):
- self.run_test(2, 1, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_02_32x16(self):
- self.run_test(32, 16, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_03_64x32(self):
- self.run_test(64, 32, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_04_128x64(self):
- self.run_test(128, 64, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_05_256x128(self):
- self.run_test(256, 128, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_06_512x256(self):
- self.run_test(512, 256, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_07_1024x512(self):
- self.run_test(1024, 512, self.gen_data_copy_numpy)
-
- @pytest.mark.benchmark(group="run-sim")
- def test_run_numpy_cp_08_2048x1024(self):
- self.run_test(2048, 1024, self.gen_data_copy_numpy)
+ self.run_test(2048, 1024, self.gen_data_copy)
diff --git a/benchmarks/sdk/test_io.py b/benchmarks/sdk/test_io.py
index 11042148d7687d556dcf74bafbeb890acbe2736b..47d8324822f9261b0f6110f319294619c8af2c31 100644
--- a/benchmarks/sdk/test_io.py
+++ b/benchmarks/sdk/test_io.py
@@ -21,22 +21,16 @@ class TestPushPull(unittest.TestCase):
self.time += dt.timedelta(days=1)
self.counter += 1
- def setup_link(self, grid, target_units, xr=False):
+ def setup_link(self, grid, target_units):
self.time = dt.datetime(2000, 1, 1)
info1 = fm.Info(time=self.time, grid=grid, units="m")
info2 = fm.Info(time=self.time, grid=grid, units=target_units)
self.data = [
- fm.data.full(0.0, "test", info1),
- fm.data.full(0.0, "test", info1),
+ fm.data.full(0.0, info1),
+ fm.data.full(0.0, info1),
]
- if not xr:
- self.data = [
- fm.data.strip_data(self.data[0]),
- fm.data.strip_data(self.data[1]),
- ]
-
self.out = fm.Output(name="Output")
self.inp = fm.Input(name="Input")
@@ -92,51 +86,3 @@ class TestPushPull(unittest.TestCase):
grid = fm.UniformGrid((2048, 1024))
self.setup_link(grid, target_units="km")
self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_01_2x1(self):
- grid = fm.UniformGrid((2, 1))
- self.setup_link(grid, target_units="m", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_02_512x256(self):
- grid = fm.UniformGrid((512, 256))
- self.setup_link(grid, target_units="m", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_03_1024x512(self):
- grid = fm.UniformGrid((1024, 512))
- self.setup_link(grid, target_units="m", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_04_2048x1024(self):
- grid = fm.UniformGrid((2048, 1024))
- self.setup_link(grid, target_units="m", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_units_01_2x1(self):
- grid = fm.UniformGrid((2, 1))
- self.setup_link(grid, target_units="km", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_units_02_512x256(self):
- grid = fm.UniformGrid((512, 256))
- self.setup_link(grid, target_units="km", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_units_03_1024x512(self):
- grid = fm.UniformGrid((1024, 512))
- self.setup_link(grid, target_units="km", xr=True)
- self.benchmark(self.push_pull)
-
- @pytest.mark.benchmark(group="sdk-io")
- def test_push_pull_xr_units_04_2048x1024(self):
- grid = fm.UniformGrid((2048, 1024))
- self.setup_link(grid, target_units="km", xr=True)
- self.benchmark(self.push_pull)