From 1ea56df2ec4353b2afae6ba01cd031b9de2b1f71 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Mon, 24 Jun 2024 14:09:14 -0500 Subject: [PATCH 01/17] Add fixtures --- thicket/tests/conftest.py | 8 ++++++++ thicket/tests/test_tree.py | 4 ++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index 7f2d6378..c18490be 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -12,6 +12,14 @@ from thicket import Thicket +@pytest.fixture(params=[True, False]) +def fill_perfdata(request): + return request.param + +@pytest.fixture(params=[True, False]) +def intersection(request): + return request.param + @pytest.fixture def thicket_axis_columns(rajaperf_cali_1trial): """Generator for 'concat_thickets(axis="columns")' thicket. diff --git a/thicket/tests/test_tree.py b/thicket/tests/test_tree.py index 298a28b2..f411ae0b 100644 --- a/thicket/tests/test_tree.py +++ b/thicket/tests/test_tree.py @@ -8,8 +8,8 @@ import thicket as th -def test_indices(rajaperf_unique_tunings): - tk = th.Thicket.from_caliperreader(rajaperf_unique_tunings) +def test_indices(rajaperf_unique_tunings, intersection, fill_perfdata): + tk = th.Thicket.from_caliperreader(rajaperf_unique_tunings, intersection=intersection, fill_perfdata=fill_perfdata, disable_tqdm=True) # No error tk.tree(metric_column="Avg time/rank", indices=tk.profile[0]) From 1f1bdb7e7ca1a9b5191c3f73c7ad53e8a3f8e9c0 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Mon, 24 Jun 2024 17:57:12 -0500 Subject: [PATCH 02/17] Add fixtures to some unit tests --- thicket/tests/conftest.py | 2 ++ thicket/tests/test_caliperreader.py | 18 ++++++++++--- thicket/tests/test_concat_thickets.py | 37 +++++++++++++++++++++------ thicket/tests/test_copy.py | 18 ++++++++++--- thicket/tests/test_display.py | 27 ++++++++++++++----- thicket/tests/test_tree.py | 7 ++++- 6 files changed, 86 insertions(+), 23 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index c18490be..30238f7a 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -16,10 +16,12 @@ def fill_perfdata(request): return request.param + @pytest.fixture(params=[True, False]) def intersection(request): return request.param + @pytest.fixture def thicket_axis_columns(rajaperf_cali_1trial): """Generator for 'concat_thickets(axis="columns")' thicket. diff --git a/thicket/tests/test_caliperreader.py b/thicket/tests/test_caliperreader.py index 885f0baf..0e39539e 100644 --- a/thicket/tests/test_caliperreader.py +++ b/thicket/tests/test_caliperreader.py @@ -6,9 +6,14 @@ from thicket import Thicket -def test_from_caliperreader(rajaperf_seq_O3_1M_cali): +def test_from_caliperreader(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): """Sanity test a thicket object with known data.""" - tk = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0], disable_tqdm=True) + tk = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Check the object type assert isinstance(tk, Thicket) @@ -25,10 +30,15 @@ def test_from_caliperreader(rajaperf_seq_O3_1M_cali): ) -def test_node_ordering_from_caliper(caliper_ordered): +def test_node_ordering_from_caliper(caliper_ordered, intersection, fill_perfdata): """Check the order of output from the native Caliper reader by examining a known input with node order column.""" - tk = Thicket.from_caliperreader(caliper_ordered) + tk = Thicket.from_caliperreader( + caliper_ordered, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) expected_order = [ "main", diff --git a/thicket/tests/test_concat_thickets.py b/thicket/tests/test_concat_thickets.py index 7c2a3030..53e214e4 100644 --- a/thicket/tests/test_concat_thickets.py +++ b/thicket/tests/test_concat_thickets.py @@ -17,14 +17,30 @@ from thicket.utils import DuplicateIndexError -def test_concat_thickets_index(mpi_scaling_cali): - th_27 = Thicket.from_caliperreader(mpi_scaling_cali[0], disable_tqdm=True) - th_64 = Thicket.from_caliperreader(mpi_scaling_cali[1], disable_tqdm=True) - - tk = Thicket.concat_thickets([th_27, th_64], disable_tqdm=True) +def test_concat_thickets_index(mpi_scaling_cali, intersection, fill_perfdata): + th_27 = Thicket.from_caliperreader( + mpi_scaling_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) + th_64 = Thicket.from_caliperreader( + mpi_scaling_cali[1], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) - # Check dataframe shape - assert tk.dataframe.shape == (90, 7) + if intersection: + calltree = "intersection" + else: + calltree = "union" + tk = Thicket.concat_thickets( + [th_27, th_64], + calltree=calltree, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Check specific values. Row order can vary so use "sum" to check node = tk.dataframe.index.get_level_values("node")[8] @@ -34,7 +50,12 @@ def test_concat_thickets_index(mpi_scaling_cali): with pytest.raises( DuplicateIndexError, ): - Thicket.from_caliperreader([mpi_scaling_cali[0], mpi_scaling_cali[0]]) + Thicket.from_caliperreader( + [mpi_scaling_cali[0], mpi_scaling_cali[0]], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) def test_concat_thickets_columns(thicket_axis_columns): diff --git a/thicket/tests/test_copy.py b/thicket/tests/test_copy.py index 873ba30a..4bd4e306 100644 --- a/thicket/tests/test_copy.py +++ b/thicket/tests/test_copy.py @@ -6,8 +6,13 @@ from thicket import Thicket -def test_copy(rajaperf_seq_O3_1M_cali): - self = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0], disable_tqdm=True) +def test_copy(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + self = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) self.exc_metrics.append("value") other = self.copy() @@ -67,8 +72,13 @@ def test_copy(rajaperf_seq_O3_1M_cali): ) -def test_deepcopy(rajaperf_seq_O3_1M_cali): - self = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0], disable_tqdm=True) +def test_deepcopy(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + self = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) self.exc_metrics.append("value") other = self.deepcopy() diff --git a/thicket/tests/test_display.py b/thicket/tests/test_display.py index a85ef83f..44336973 100644 --- a/thicket/tests/test_display.py +++ b/thicket/tests/test_display.py @@ -10,8 +10,13 @@ import thicket as th -def test_display_histogram(rajaperf_seq_O3_1M_cali): - tk = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_display_histogram(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + tk = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) node = pd.unique(tk.dataframe.reset_index()["node"])[4] @@ -78,8 +83,13 @@ def test_display_histogram_columnar_join(thicket_axis_columns): plt.close() -def test_display_heatmap(rajaperf_seq_O3_1M_cali): - tk = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_display_heatmap(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + tk = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th.stats.variance(tk, columns=["Min time/rank"]) @@ -151,8 +161,13 @@ def test_display_heatmap_columnar_join(thicket_axis_columns): plt.close() -def test_display_boxplot(rajaperf_seq_O3_1M_cali): - tk = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_display_boxplot(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + tk = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) nodes = list(pd.unique(tk.dataframe.reset_index()["node"])[0:2]) diff --git a/thicket/tests/test_tree.py b/thicket/tests/test_tree.py index f411ae0b..12d02d23 100644 --- a/thicket/tests/test_tree.py +++ b/thicket/tests/test_tree.py @@ -9,7 +9,12 @@ def test_indices(rajaperf_unique_tunings, intersection, fill_perfdata): - tk = th.Thicket.from_caliperreader(rajaperf_unique_tunings, intersection=intersection, fill_perfdata=fill_perfdata, disable_tqdm=True) + tk = th.Thicket.from_caliperreader( + rajaperf_unique_tunings, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # No error tk.tree(metric_column="Avg time/rank", indices=tk.profile[0]) From 8bd85bc553fd5a0b595a65beabe4573b63900055 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 26 Jun 2024 13:55:17 -0500 Subject: [PATCH 03/17] Add ids to parameter values --- thicket/tests/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index 30238f7a..a46d709a 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -12,12 +12,12 @@ from thicket import Thicket -@pytest.fixture(params=[True, False]) +@pytest.fixture(params=[True, False], ids=["Padding", "NoPadding"]) def fill_perfdata(request): return request.param -@pytest.fixture(params=[True, False]) +@pytest.fixture(params=[True, False], ids=["Intersection", "Union"]) def intersection(request): return request.param From 7204bcddfeab3425d388e730351d476c25774ef8 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 26 Jun 2024 15:16:55 -0500 Subject: [PATCH 04/17] Add parametrization to remaining unit tests --- thicket/tests/conftest.py | 25 +++-- thicket/tests/test_filter_metadata.py | 18 +++- thicket/tests/test_filter_stats.py | 9 +- thicket/tests/test_from_statsframes.py | 24 ++++- thicket/tests/test_groupby.py | 40 ++++++-- thicket/tests/test_intersection.py | 12 ++- thicket/tests/test_model_extrap.py | 18 +++- thicket/tests/test_pickle.py | 9 +- thicket/tests/test_query.py | 45 +++++++-- thicket/tests/test_query_stats.py | 43 +++++++-- thicket/tests/test_stats.py | 126 +++++++++++++++++++------ thicket/tests/test_thicket.py | 25 ++++- 12 files changed, 311 insertions(+), 83 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index a46d709a..a4b42749 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -12,7 +12,7 @@ from thicket import Thicket -@pytest.fixture(params=[True, False], ids=["Padding", "NoPadding"]) +@pytest.fixture(params=[True, False], ids=["PadPerfdata", "NoPadPerfdata"]) def fill_perfdata(request): return request.param @@ -23,7 +23,7 @@ def intersection(request): @pytest.fixture -def thicket_axis_columns(rajaperf_cali_1trial): +def thicket_axis_columns(rajaperf_cali_1trial, intersection, fill_perfdata): """Generator for 'concat_thickets(axis="columns")' thicket. Arguments: @@ -34,7 +34,12 @@ def thicket_axis_columns(rajaperf_cali_1trial): list: List of original thickets, list of deepcopies of original thickets, and column-joined thicket. """ - tk = Thicket.from_caliperreader(rajaperf_cali_1trial, disable_tqdm=True) + tk = Thicket.from_caliperreader( + rajaperf_cali_1trial, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) gb = tk.groupby("tuning") @@ -55,7 +60,9 @@ def thicket_axis_columns(rajaperf_cali_1trial): @pytest.fixture -def stats_thicket_axis_columns(rajaperf_cuda_block128_1M_cali): +def stats_thicket_axis_columns( + rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata +): """Generator for 'concat_thickets(axis="columns")' thicket for test_stats.py. Arguments: @@ -66,10 +73,16 @@ def stats_thicket_axis_columns(rajaperf_cuda_block128_1M_cali): column-joined thicket. """ th_cuda128_1 = Thicket.from_caliperreader( - rajaperf_cuda_block128_1M_cali[0:4], disable_tqdm=True + rajaperf_cuda_block128_1M_cali[0:4], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, ) th_cuda128_2 = Thicket.from_caliperreader( - rajaperf_cuda_block128_1M_cali[5:9], disable_tqdm=True + rajaperf_cuda_block128_1M_cali[5:9], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, ) # To check later if modifications were unexpectedly made diff --git a/thicket/tests/test_filter_metadata.py b/thicket/tests/test_filter_metadata.py index 3c63d95a..c60052fc 100644 --- a/thicket/tests/test_filter_metadata.py +++ b/thicket/tests/test_filter_metadata.py @@ -163,8 +163,13 @@ def filter_multiple_or(th, columns_values): assert "name" in new_th.statsframe.dataframe.columns -def test_check_errors(rajaperf_seq_O3_1M_cali): - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_check_errors(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # check for invalid filter exception with pytest.raises(InvalidFilter): @@ -192,9 +197,14 @@ def test_check_errors(rajaperf_seq_O3_1M_cali): th.filter_metadata(lambda x: x["cluster"] == "quartz") -def test_filter_metadata(rajaperf_seq_O3_1M_cali): +def test_filter_metadata(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): # example thicket - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # columns and corresponding values to filter by columns_values = {"ProblemSizeRunParam": [1048576.0], "cluster": ["quartz"]} filter_one_column(th, columns_values) diff --git a/thicket/tests/test_filter_stats.py b/thicket/tests/test_filter_stats.py index 7a2074d2..8f1e45d0 100644 --- a/thicket/tests/test_filter_stats.py +++ b/thicket/tests/test_filter_stats.py @@ -54,9 +54,14 @@ def check_filter_stats(th, columns_values): assert ensemble_nodes == exp_nodes -def test_filter_stats(rajaperf_seq_O3_1M_cali): +def test_filter_stats(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): # example thicket - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # columns and corresponding values to filter by columns_values = { "test_string_column": ["less than 20"], diff --git a/thicket/tests/test_from_statsframes.py b/thicket/tests/test_from_statsframes.py index 297da20b..27078b27 100644 --- a/thicket/tests/test_from_statsframes.py +++ b/thicket/tests/test_from_statsframes.py @@ -9,10 +9,17 @@ from thicket.utils import DuplicateValueError -def test_single_trial(mpi_scaling_cali): +def test_single_trial(mpi_scaling_cali, intersection, fill_perfdata): th_list = [] for file in mpi_scaling_cali: - th_list.append(th.Thicket.from_caliperreader(file, disable_tqdm=True)) + th_list.append( + th.Thicket.from_caliperreader( + file, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) + ) # Add arbitrary value to aggregated statistics table t_val = 0 @@ -49,8 +56,17 @@ def test_single_trial(mpi_scaling_cali): assert set(tk_named.dataframe["test"]) == {0, 2, 4, 6, 8} -def test_multi_trial(rajaperf_cali_alltrials): - tk = th.Thicket.from_caliperreader(rajaperf_cali_alltrials) +def test_multi_trial( + rajaperf_cali_alltrials, + intersection, + fill_perfdata, +): + tk = th.Thicket.from_caliperreader( + rajaperf_cali_alltrials, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Simulate multiple trial from grouping by tuning. gb = tk.groupby("tuning") diff --git a/thicket/tests/test_groupby.py b/thicket/tests/test_groupby.py index ebe208b2..c2acb371 100644 --- a/thicket/tests/test_groupby.py +++ b/thicket/tests/test_groupby.py @@ -81,8 +81,13 @@ def check_groupby(th, columns_values): th.groupby(["user"]) -def test_aggregate(rajaperf_cuda_block128_1M_cali): - tk = Thicket.from_caliperreader(rajaperf_cuda_block128_1M_cali, disable_tqdm=True) +def test_aggregate(rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata): + tk = Thicket.from_caliperreader( + rajaperf_cuda_block128_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) gb = tk.groupby("spot.format.version") epsilon = 0.000001 @@ -120,19 +125,31 @@ def _check_values(_tk_agg): _check_values(tk_agg) -def test_groupby(rajaperf_seq_O3_1M_cali): +def test_groupby(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): # example thicket - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # use cases for string, numeric, and single value columns columns_values = ["user", "launchdate", "cali.channel"] check_groupby(th, columns_values) -def test_groupby_concat_thickets_columns(rajaperf_seq_O3_1M_cali): +def test_groupby_concat_thickets_columns( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): """Tests case where the Sub-Thickets of a groupby are used in a columnar join""" # example thicket - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Creates four Sub-Thickets column = "unique_col" @@ -158,10 +175,17 @@ def test_groupby_concat_thickets_columns(rajaperf_seq_O3_1M_cali): test_concat_thickets_columns((thickets, thickets_cp, combined_th)) -def test_groupby_concat_thickets_columns_subthickets(rajaperf_seq_O3_1M_cali): +def test_groupby_concat_thickets_columns_subthickets( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): """Tests case where some specific Sub-Thickets of a groupby are used in a columnar join""" # example thicket - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Creates four Sub-Thickets column = "unique_col" diff --git a/thicket/tests/test_intersection.py b/thicket/tests/test_intersection.py index c259d55f..f2f2a769 100644 --- a/thicket/tests/test_intersection.py +++ b/thicket/tests/test_intersection.py @@ -7,11 +7,17 @@ from thicket import Thicket as th -def test_intersection(rajaperf_cali_1trial): - tk = th.from_caliperreader(rajaperf_cali_1trial, disable_tqdm=True) - +def test_intersection(rajaperf_cali_1trial, fill_perfdata): + # Manually intersect + tk = th.from_caliperreader( + rajaperf_cali_1trial, + intersection=False, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) intersected_tk = tk.intersection() + # Use argument during reader intersected_tk_other = th.from_caliperreader( rajaperf_cali_1trial, intersection=True, disable_tqdm=True ) diff --git a/thicket/tests/test_model_extrap.py b/thicket/tests/test_model_extrap.py index 3a1cbb9d..4558473b 100644 --- a/thicket/tests/test_model_extrap.py +++ b/thicket/tests/test_model_extrap.py @@ -32,10 +32,15 @@ pytest.skip("Extra-P package not available", allow_module_level=True) -def test_model_extrap(mpi_scaling_cali): +def test_model_extrap(mpi_scaling_cali, intersection, fill_perfdata): from thicket.model_extrap import Modeling - t_ens = Thicket.from_caliperreader(mpi_scaling_cali, disable_tqdm=True) + t_ens = Thicket.from_caliperreader( + mpi_scaling_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Method 1: Model created using metadata column mdl = Modeling( @@ -73,10 +78,15 @@ def test_model_extrap(mpi_scaling_cali): ) -def test_componentize_functions(mpi_scaling_cali): +def test_componentize_functions(mpi_scaling_cali, intersection, fill_perfdata): from thicket.model_extrap import Modeling - t_ens = Thicket.from_caliperreader(mpi_scaling_cali, disable_tqdm=True) + t_ens = Thicket.from_caliperreader( + mpi_scaling_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) mdl = Modeling( t_ens, diff --git a/thicket/tests/test_pickle.py b/thicket/tests/test_pickle.py index 396d2732..ba72aa01 100644 --- a/thicket/tests/test_pickle.py +++ b/thicket/tests/test_pickle.py @@ -6,11 +6,16 @@ import thicket as th -def test_pickle(rajaperf_cali_1trial, tmpdir): +def test_pickle(rajaperf_cali_1trial, tmpdir, intersection, fill_perfdata): """Test pickling and unpickling of Thicket object.""" # Create thicket - tk = th.Thicket.from_caliperreader(rajaperf_cali_1trial) + tk = th.Thicket.from_caliperreader( + rajaperf_cali_1trial, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Create temporary pickle file and write to it pkl_file = tmpdir.join("tk.pkl") diff --git a/thicket/tests/test_query.py b/thicket/tests/test_query.py index d451f356..287933be 100644 --- a/thicket/tests/test_query.py +++ b/thicket/tests/test_query.py @@ -51,9 +51,14 @@ def check_query(th, hnids, query): check_identity(th, filt_th, "default_metric") -def test_query(rajaperf_cuda_block128_1M_cali): +def test_query(rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata): # test thicket - th = Thicket.from_caliperreader(rajaperf_cuda_block128_1M_cali, disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_cuda_block128_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # test arguments hnids = [0, 1, 2, 3, 4] # 5, 6, 7 have Nones query = ( @@ -70,9 +75,21 @@ def test_query(rajaperf_cuda_block128_1M_cali): check_query(th, hnids, query) -def test_object_dialect_column_multi_index(rajaperf_seq_O3_1M_cali): - th1 = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0]) - th2 = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[1]) +def test_object_dialect_column_multi_index( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): + th1 = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) + th2 = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[1], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th_cj = Thicket.concat_thickets([th1, th2], axis="columns") query = [ @@ -108,9 +125,21 @@ def test_object_dialect_column_multi_index(rajaperf_seq_O3_1M_cali): ).all() -def test_string_dialect_column_multi_index(rajaperf_seq_O3_1M_cali): - th1 = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0]) - th2 = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[1]) +def test_string_dialect_column_multi_index( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): + th1 = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) + th2 = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[1], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th_cj = Thicket.concat_thickets([th1, th2], axis="columns") query = """MATCH ("+", p) diff --git a/thicket/tests/test_query_stats.py b/thicket/tests/test_query_stats.py index 6a7af368..e98cc2a5 100644 --- a/thicket/tests/test_query_stats.py +++ b/thicket/tests/test_query_stats.py @@ -61,10 +61,13 @@ def check_query(th_x, hnids, query): check_identity(th_x, filt_th, "default_metric") -def test_query_stats(rajaperf_cuda_block128_1M_cali): +def test_query_stats(rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata): # test thicket th_x = th.Thicket.from_caliperreader( - rajaperf_cuda_block128_1M_cali, disable_tqdm=True + rajaperf_cuda_block128_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, ) th.stats.mean(th_x, columns=["Min time/rank"]) # test arguments @@ -78,9 +81,21 @@ def test_query_stats(rajaperf_cuda_block128_1M_cali): check_query(th_x, hnids, query) -def test_object_dialect_column_multi_index(rajaperf_seq_O3_1M_cali): - th1 = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0]) - th2 = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[1]) +def test_object_dialect_column_multi_index( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): + th1 = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) + th2 = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[1], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th_cj = th.Thicket.concat_thickets([th1, th2], axis="columns") th.stats.mean(th_cj, columns=[(0, "Min time/rank")]) @@ -135,9 +150,21 @@ def test_object_dialect_column_multi_index(rajaperf_seq_O3_1M_cali): ).all() -def test_string_dialect_column_multi_index(rajaperf_seq_O3_1M_cali): - th1 = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0]) - th2 = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[1]) +def test_string_dialect_column_multi_index( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): + th1 = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[0], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) + th2 = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[1], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th_cj = th.Thicket.concat_thickets([th1, th2], axis="columns") th.stats.mean(th_cj, columns=[(0, "Min time/rank")]) diff --git a/thicket/tests/test_stats.py b/thicket/tests/test_stats.py index fa5382fa..ce01ae99 100644 --- a/thicket/tests/test_stats.py +++ b/thicket/tests/test_stats.py @@ -11,8 +11,13 @@ import thicket as th -def test_mean(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_mean(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -49,8 +54,13 @@ def test_mean_columnar_join(thicket_axis_columns): assert (idx, "Min time/rank_mean") in combined_th.statsframe.show_metric_columns() -def test_median(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_median(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -87,8 +97,13 @@ def test_median_columnar_join(thicket_axis_columns): assert (idx, "Min time/rank_median") in combined_th.statsframe.show_metric_columns() -def test_minimum(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_minimum(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -125,8 +140,13 @@ def test_minimum_columnar_join(thicket_axis_columns): assert (idx, "Min time/rank_min") in combined_th.statsframe.show_metric_columns() -def test_maximum(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_maximum(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -163,8 +183,13 @@ def test_maximum_columnar_join(thicket_axis_columns): assert (idx, "Min time/rank_max") in combined_th.statsframe.show_metric_columns() -def test_std(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_std(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -201,8 +226,13 @@ def test_std_columnar_join(thicket_axis_columns): assert (idx, "Min time/rank_std") in combined_th.statsframe.show_metric_columns() -def test_percentiles(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_percentiles(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -232,8 +262,13 @@ def test_percentiles(rajaperf_seq_O3_1M_cali): assert "Min time/rank_percentiles_75" in th_ens.statsframe.show_metric_columns() -def test_percentiles_none(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_percentiles_none(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th.stats.percentiles(th_ens, columns=["Min time/rank"], percentiles=None) @@ -242,8 +277,13 @@ def test_percentiles_none(rajaperf_seq_O3_1M_cali): assert "Min time/rank_percentiles_75" in th_ens.statsframe.dataframe.columns -def test_percentiles_single_value(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_percentiles_single_value(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) th.stats.percentiles(th_ens, columns=["Min time/rank"], percentiles=[0.3]) @@ -366,8 +406,13 @@ def test_percentiles_columnar_join(thicket_axis_columns): ) in combined_th.statsframe.show_metric_columns() -def test_variance(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_variance(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -385,7 +430,7 @@ def test_variance(rajaperf_seq_O3_1M_cali): assert "Min time/rank_var" in th_ens.statsframe.show_metric_columns() -def test_variance_columnar_join(thicket_axis_columns): +def test_variance_columnar_join(thicket_axis_columns, intersection, fill_perfdata): thicket_list, thicket_list_cp, combined_th = thicket_axis_columns idx = combined_th.dataframe.columns.levels[0][0] assert sorted(combined_th.dataframe.index.get_level_values(0).unique()) == sorted( @@ -404,9 +449,12 @@ def test_variance_columnar_join(thicket_axis_columns): assert (idx, "Min time/rank_var") in combined_th.statsframe.show_metric_columns() -def test_normality(rajaperf_cuda_block128_1M_cali): +def test_normality(rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata): th_ens = th.Thicket.from_caliperreader( - rajaperf_cuda_block128_1M_cali, disable_tqdm=True + rajaperf_cuda_block128_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( @@ -461,9 +509,12 @@ def test_normality_columnar_join(thicket_axis_columns, stats_thicket_axis_column ) in scombined_th.statsframe.show_metric_columns() -def test_correlation(rajaperf_cuda_block128_1M_cali): +def test_correlation(rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata): th_ens = th.Thicket.from_caliperreader( - rajaperf_cuda_block128_1M_cali, disable_tqdm=True + rajaperf_cuda_block128_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( @@ -503,8 +554,13 @@ def test_correlation_columnar_join(thicket_axis_columns): ) in combined_th.statsframe.dataframe.columns -def test_boxplot(rajaperf_seq_O3_1M_cali): - th_ens = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=True) +def test_boxplot(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_ens = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) assert sorted(th_ens.dataframe.index.get_level_values(0).unique()) == sorted( th_ens.statsframe.dataframe.index.values @@ -1190,8 +1246,15 @@ def test_score_hellinger(thicket_axis_columns): ) -def test_reapply_statsframe_operations(rajaperf_seq_O3_1M_cali): - th_1 = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=False) +def test_reapply_statsframe_operations( + rajaperf_seq_O3_1M_cali, intersection, fill_perfdata +): + th_1 = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=False, + ) th.stats.mean(th_1, columns=["Min time/rank"]) @@ -1209,8 +1272,13 @@ def test_reapply_statsframe_operations(rajaperf_seq_O3_1M_cali): assert all([comp_val[c].all() for c in comp_val.columns]) -def test_cache_decorator(rajaperf_seq_O3_1M_cali): - th_1 = th.Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali, disable_tqdm=False) +def test_cache_decorator(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): + th_1 = th.Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=False, + ) th.stats.mean(th_1, columns=["Min time/rank"]) diff --git a/thicket/tests/test_thicket.py b/thicket/tests/test_thicket.py index 52a46736..1ba430c5 100644 --- a/thicket/tests/test_thicket.py +++ b/thicket/tests/test_thicket.py @@ -47,7 +47,7 @@ def test_resolve_missing_indicies(): assert set(names_1).issubset(th_1.dataframe.index.names) -def test_statsframe(rajaperf_seq_O3_1M_cali): +def test_statsframe(rajaperf_seq_O3_1M_cali, intersection, fill_perfdata): def _test_multiindex(): """Test statsframe when headers are multiindexed.""" th1 = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[0], disable_tqdm=True) @@ -59,7 +59,12 @@ def _test_multiindex(): _test_multiindex() - th = Thicket.from_caliperreader(rajaperf_seq_O3_1M_cali[-1], disable_tqdm=True) + th = Thicket.from_caliperreader( + rajaperf_seq_O3_1M_cali[-1], + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, + ) # Arbitrary value insertion in aggregated statistics table. th.statsframe.dataframe["test"] = 1 @@ -81,10 +86,15 @@ def _test_multiindex(): def test_metadata_columns_to_perfdata( - rajaperf_cuda_block128_1M_cali, rajaperf_seq_O3_1M_cali + rajaperf_cuda_block128_1M_cali, + rajaperf_seq_O3_1M_cali, + intersection, + fill_perfdata ): tk = Thicket.from_caliperreader( [rajaperf_cuda_block128_1M_cali[0], rajaperf_seq_O3_1M_cali[0]], + intersection=intersection, + fill_perfdata=fill_perfdata, disable_tqdm=True, ) tkc1 = tk.deepcopy() @@ -196,9 +206,14 @@ def test_thicketize_graphframe(rajaperf_seq_O3_1M_cali): assert ht1.dataframe.equals(th1.dataframe) -def test_unique_metadata_base_cuda(rajaperf_cuda_block128_1M_cali): +def test_unique_metadata_base_cuda( + rajaperf_cuda_block128_1M_cali, intersection, fill_perfdata +): t_ens = Thicket.from_caliperreader( - rajaperf_cuda_block128_1M_cali, disable_tqdm=True + rajaperf_cuda_block128_1M_cali, + intersection=intersection, + fill_perfdata=fill_perfdata, + disable_tqdm=True, ) res = t_ens.get_unique_metadata() From b9fa9d4c74db0cb38395c857d9a5676aae6d085d Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 26 Jun 2024 16:11:00 -0500 Subject: [PATCH 05/17] Fix unit test --- thicket/tests/test_from_statsframes.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/thicket/tests/test_from_statsframes.py b/thicket/tests/test_from_statsframes.py index 27078b27..ff3a3d08 100644 --- a/thicket/tests/test_from_statsframes.py +++ b/thicket/tests/test_from_statsframes.py @@ -85,4 +85,7 @@ def test_multi_trial( [list(gb.values())[0], list(gb.values())[0]], metadata_key="tuning" ) - assert stk.dataframe.shape == (222, 2) + if intersection == False: + assert stk.dataframe.shape == (222, 2) + else: + assert stk.dataframe.shape == (192, 2) \ No newline at end of file From 1fd3e93e6a7fa95d3974f31da8ad068544cdd529 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Tue, 9 Jul 2024 16:48:06 -0500 Subject: [PATCH 06/17] black --- thicket/tests/test_from_statsframes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/thicket/tests/test_from_statsframes.py b/thicket/tests/test_from_statsframes.py index ff3a3d08..26a34abd 100644 --- a/thicket/tests/test_from_statsframes.py +++ b/thicket/tests/test_from_statsframes.py @@ -88,4 +88,4 @@ def test_multi_trial( if intersection == False: assert stk.dataframe.shape == (222, 2) else: - assert stk.dataframe.shape == (192, 2) \ No newline at end of file + assert stk.dataframe.shape == (192, 2) From 0d3a8a0f299c48948d18848a50ac738f60884a4c Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Tue, 9 Jul 2024 16:55:33 -0500 Subject: [PATCH 07/17] Fix logic for flake --- thicket/tests/test_from_statsframes.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/thicket/tests/test_from_statsframes.py b/thicket/tests/test_from_statsframes.py index 26a34abd..23ecacf8 100644 --- a/thicket/tests/test_from_statsframes.py +++ b/thicket/tests/test_from_statsframes.py @@ -85,7 +85,7 @@ def test_multi_trial( [list(gb.values())[0], list(gb.values())[0]], metadata_key="tuning" ) - if intersection == False: - assert stk.dataframe.shape == (222, 2) - else: + if intersection: assert stk.dataframe.shape == (192, 2) + else: + assert stk.dataframe.shape == (222, 2) From 05747f8871533661b0f8b0da3c2c05e0b013b58e Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Tue, 9 Jul 2024 17:26:04 -0500 Subject: [PATCH 08/17] Fix unit tests --- thicket/tests/test_concat_thickets.py | 54 ++++++++++++++++++--------- 1 file changed, 36 insertions(+), 18 deletions(-) diff --git a/thicket/tests/test_concat_thickets.py b/thicket/tests/test_concat_thickets.py index 53e214e4..b2f2e9ca 100644 --- a/thicket/tests/test_concat_thickets.py +++ b/thicket/tests/test_concat_thickets.py @@ -111,9 +111,9 @@ def test_filter_concat_thickets_columns(thicket_axis_columns): filter_multiple_and(combined_th, columns_values) -def test_filter_stats_concat_thickets_columns(thicket_axis_columns): +def test_filter_stats_concat_thickets_columns(thicket_axis_columns, intersection): thickets, thickets_cp, combined_th = thicket_axis_columns - # columns and corresponding values to filter by + columns_values = { ("test", "test_string_column"): ["less than 20"], ("test", "test_numeric_column"): [4, 15], @@ -121,28 +121,46 @@ def test_filter_stats_concat_thickets_columns(thicket_axis_columns): # set string column values less_than_20 = ["less than 20"] * 21 less_than_45 = ["less than 45"] * 25 - less_than_178 = ["less than 75"] * 28 - new_col = less_than_20 + less_than_45 + less_than_178 - combined_th.statsframe.dataframe[("test", "test_string_column")] = new_col - # set numeric column values - combined_th.statsframe.dataframe[("test", "test_numeric_column")] = range(0, 74) + + if intersection: + less_than_65 = ["less than 65"] * 18 + new_col = less_than_20 + less_than_45 + less_than_65 + combined_th.statsframe.dataframe[("test", "test_string_column")] = new_col + # set numeric column values + combined_th.statsframe.dataframe[("test", "test_numeric_column")] = range(0, 64) + else: + less_than_75 = ["less than 75"] * 28 + new_col = less_than_20 + less_than_45 + less_than_75 + combined_th.statsframe.dataframe[("test", "test_string_column")] = new_col + # set numeric column values + combined_th.statsframe.dataframe[("test", "test_numeric_column")] = range(0, 74) check_filter_stats(combined_th, columns_values) -def test_query_concat_thickets_columns(thicket_axis_columns): +def test_query_concat_thickets_columns(thicket_axis_columns, intersection): thickets, thickets_cp, combined_th = thicket_axis_columns # test arguments - hnids = [ - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - ] # "0" because top-level node "RAJAPerf" will be included in query result. + if intersection: + # Shorter graph for intersection + hnids = [ + 0, + 1, + 2, + 3, + 4, + ] + else: + hnids = [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + ] # "0" because top-level node "RAJAPerf" will be included in query result. query = ( ht.QueryMatcher() .match("*") From d017604fa7dea4f727b25bf88759b5cbcfdd4bd3 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Thu, 11 Jul 2024 14:07:09 -0500 Subject: [PATCH 09/17] Update --- thicket/tests/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index a4b42749..7980f785 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -12,7 +12,7 @@ from thicket import Thicket -@pytest.fixture(params=[True, False], ids=["PadPerfdata", "NoPadPerfdata"]) +@pytest.fixture(params=[True, False], ids=["FillPerfdata", "NoFillPerfdata"]) def fill_perfdata(request): return request.param From f15ecfcec947da8945da5f18dca75ef961995a22 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 17 Jul 2024 11:53:22 -0500 Subject: [PATCH 10/17] run intersection on column thicket --- thicket/tests/conftest.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index 7980f785..a3833e9b 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -48,9 +48,11 @@ def thicket_axis_columns(rajaperf_cali_1trial, intersection, fill_perfdata): # To check later if modifications were unexpectedly made thickets_cp = [t.deepcopy() for t in thickets] + calltrees = ["union", "intersection"] combined_th = Thicket.concat_thickets( thickets=thickets, axis="columns", + calltree=calltrees[intersection], headers=headers, metadata_key="ProblemSizeRunParam", disable_tqdm=True, From b5342b61c2201e8c2f020de63a69ca904f0b1046 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 17 Jul 2024 11:54:27 -0500 Subject: [PATCH 11/17] Fix docstring --- thicket/tests/conftest.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index a3833e9b..553edba2 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -27,8 +27,9 @@ def thicket_axis_columns(rajaperf_cali_1trial, intersection, fill_perfdata): """Generator for 'concat_thickets(axis="columns")' thicket. Arguments: - mpi_scaling_cali (list): List of Caliper files for MPI scaling study. - rajaperf_cuda_block128_1M_cali (list): List of Caliper files for base cuda variant. + rajaperf_cali_1trial (list): All tunings and variants for the first trial. + intersection (bool): Whether to use intersection or union for calltree. + fill_perfdata (bool): Whether to fill perfdata or not. Returns: list: List of original thickets, list of deepcopies of original thickets, and @@ -69,6 +70,8 @@ def stats_thicket_axis_columns( Arguments: rajaperf_cuda_block128_1M_cali (list): List of Caliper files for base cuda variant. + intersection (bool): Whether to use intersection or union for calltree. + fill_perfdata (bool): Whether to fill perfdata or not. Returns: list: List of original thickets, list of deepcopies of original thickets, and From 8e392f8068787b330d970dcbf15fe0f47e51d50f Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 17 Jul 2024 11:55:45 -0500 Subject: [PATCH 12/17] Add intersection test --- thicket/tests/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index 553edba2..0af5b148 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -49,11 +49,10 @@ def thicket_axis_columns(rajaperf_cali_1trial, intersection, fill_perfdata): # To check later if modifications were unexpectedly made thickets_cp = [t.deepcopy() for t in thickets] - calltrees = ["union", "intersection"] combined_th = Thicket.concat_thickets( thickets=thickets, axis="columns", - calltree=calltrees[intersection], + calltree=["union", "intersection"][intersection], headers=headers, metadata_key="ProblemSizeRunParam", disable_tqdm=True, @@ -99,6 +98,7 @@ def stats_thicket_axis_columns( combined_th = Thicket.concat_thickets( thickets=thickets, axis="columns", + calltree=["union", "intersection"][intersection], headers=["Cuda 1", "Cuda 2"], disable_tqdm=True, ) From ca6f9da2ebea5e5c322ff8f3322a561cd98a22a7 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 17 Jul 2024 13:56:57 -0500 Subject: [PATCH 13/17] Fix intersection for multiindex columns --- thicket/thicket.py | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/thicket/thicket.py b/thicket/thicket.py index 4cd2db45..d52774df 100644 --- a/thicket/thicket.py +++ b/thicket/thicket.py @@ -1187,15 +1187,26 @@ def intersection(self): (thicket): intersected thicket """ - # Check for padded perfdata - if self.dataframe["name"].isnull().any(): - # Row that didn't exist will contain "None" in the name column. - query = Query().match( - ".", lambda df: df["name"].apply(lambda n: n is not None).all() - ) + # if concat_thickets(axis="columns") + if isinstance(self.dataframe.columns, pd.MultiIndex): + rows = [] + for index in self.dataframe.index: + row = self.dataframe.loc[index] + rows.append(all([row[header].notna().all() for header in self.dataframe.columns.get_level_values(0)])) + tkc = self.deepcopy() + tkc.dataframe = tkc.dataframe[rows] + tkc = tkc.squash() + return tkc else: - # If perfdata not padded - query = Query().match(".", lambda df: len(df) == len(self.profile)) + # Check for padded perfdata + if self.dataframe["name"].isnull().any(): + # Row that didn't exist will contain "None" in the name column. + query = Query().match( + ".", lambda df: df["name"].apply(lambda n: n is not None).all() + ) + else: + # If perfdata not padded + query = Query().match(".", lambda df: len(df) == len(self.profile)) intersected_th = self.query(query) From 1cbaeb94241cd7bd032f94f00f450cdfd964e295 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 17 Jul 2024 15:04:22 -0500 Subject: [PATCH 14/17] Fix bug --- thicket/thicket.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/thicket/thicket.py b/thicket/thicket.py index d52774df..d1245c38 100644 --- a/thicket/thicket.py +++ b/thicket/thicket.py @@ -1190,9 +1190,16 @@ def intersection(self): # if concat_thickets(axis="columns") if isinstance(self.dataframe.columns, pd.MultiIndex): rows = [] - for index in self.dataframe.index: - row = self.dataframe.loc[index] - rows.append(all([row[header].notna().all() for header in self.dataframe.columns.get_level_values(0)])) + nodes = self.dataframe.index.get_level_values("node").unique() + extend_len = len(self.dataframe)//len(nodes) + for node in nodes: + df = self.dataframe.loc[node] + keep = all([df[header].notna() # We are checking for NaNs + .all() # For all values in a row + .all() # For all rows in the slice + for header in self.dataframe.columns.get_level_values(0)] # For each column header df[header] == slice + ) + rows.extend([keep]*extend_len) # Extend by extend_len for MultiIndex tkc = self.deepcopy() tkc.dataframe = tkc.dataframe[rows] tkc = tkc.squash() From 5afcae99b42dc3fe476a7c8b17dc1ced5927106b Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Wed, 17 Jul 2024 15:09:46 -0500 Subject: [PATCH 15/17] black --- thicket/thicket.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/thicket/thicket.py b/thicket/thicket.py index d1245c38..9d41ae4a 100644 --- a/thicket/thicket.py +++ b/thicket/thicket.py @@ -1191,15 +1191,19 @@ def intersection(self): if isinstance(self.dataframe.columns, pd.MultiIndex): rows = [] nodes = self.dataframe.index.get_level_values("node").unique() - extend_len = len(self.dataframe)//len(nodes) + extend_len = len(self.dataframe) // len(nodes) for node in nodes: df = self.dataframe.loc[node] - keep = all([df[header].notna() # We are checking for NaNs - .all() # For all values in a row - .all() # For all rows in the slice - for header in self.dataframe.columns.get_level_values(0)] # For each column header df[header] == slice - ) - rows.extend([keep]*extend_len) # Extend by extend_len for MultiIndex + keep = all( + [ + df[header] + .notna() # We are checking for NA + .all() # For all values in a row + .all() # For all rows in the slice + for header in self.dataframe.columns.get_level_values(0) + ] # For each column header df[header] == slice + ) + rows.extend([keep] * extend_len) # Extend by extend_len for MultiIndex tkc = self.deepcopy() tkc.dataframe = tkc.dataframe[rows] tkc = tkc.squash() From 8905b43e997b84b97193da77d17a0ebea5db3f29 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Mon, 22 Jul 2024 15:37:22 -0500 Subject: [PATCH 16/17] Change syntax --- thicket/tests/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/thicket/tests/conftest.py b/thicket/tests/conftest.py index 0af5b148..cb0c1823 100644 --- a/thicket/tests/conftest.py +++ b/thicket/tests/conftest.py @@ -52,7 +52,7 @@ def thicket_axis_columns(rajaperf_cali_1trial, intersection, fill_perfdata): combined_th = Thicket.concat_thickets( thickets=thickets, axis="columns", - calltree=["union", "intersection"][intersection], + calltree="intersection" if intersection else "union", headers=headers, metadata_key="ProblemSizeRunParam", disable_tqdm=True, @@ -98,7 +98,7 @@ def stats_thicket_axis_columns( combined_th = Thicket.concat_thickets( thickets=thickets, axis="columns", - calltree=["union", "intersection"][intersection], + calltree="intersection" if intersection else "union", headers=["Cuda 1", "Cuda 2"], disable_tqdm=True, ) From 4ea1fd13b72652a191b3b97b681de9eadc1d9ca6 Mon Sep 17 00:00:00 2001 From: Michael McKinsey Date: Fri, 25 Oct 2024 13:58:01 -0500 Subject: [PATCH 17/17] black --- thicket/tests/test_thicket.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/thicket/tests/test_thicket.py b/thicket/tests/test_thicket.py index 1ba430c5..af7375a2 100644 --- a/thicket/tests/test_thicket.py +++ b/thicket/tests/test_thicket.py @@ -86,10 +86,7 @@ def _test_multiindex(): def test_metadata_columns_to_perfdata( - rajaperf_cuda_block128_1M_cali, - rajaperf_seq_O3_1M_cali, - intersection, - fill_perfdata + rajaperf_cuda_block128_1M_cali, rajaperf_seq_O3_1M_cali, intersection, fill_perfdata ): tk = Thicket.from_caliperreader( [rajaperf_cuda_block128_1M_cali[0], rajaperf_seq_O3_1M_cali[0]],