| |
|
|
| import argparse |
| import sys |
| import textwrap |
| import warnings |
|
|
| try: |
| import plotnine as p9 |
| import polars as pl |
| from plotnine.exceptions import PlotnineWarning |
|
|
| warnings.filterwarnings("ignore", category=PlotnineWarning) |
| except ImportError: |
| print("Please install Polars and Plotnine to use this script.") |
| sys.exit(1) |
|
|
|
|
| def get_styles(exclude_solutions: list[str]): |
| all_styles = pl.from_repr( |
| """ |
| ┌──────────┬──────────┬─────────┬───────┬──────┐ |
| │ solution ┆ name ┆ color ┆ shape ┆ size │ |
| │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ |
| │ str ┆ str ┆ str ┆ str ┆ f32 │ |
| ╞══════════╪══════════╪═════════╪═══════╪══════╡ |
| │ dask ┆ Dask ┆ #ef1161 ┆ D ┆ 4.5 │ |
| │ duckdb ┆ DuckDB ┆ #fff000 ┆ o ┆ 5.0 │ |
| │ modin ┆ Modin ┆ #00abee ┆ > ┆ 5.0 │ |
| │ pandas ┆ Pandas ┆ #e70488 ┆ s ┆ 5.0 │ |
| │ polars ┆ Polars ┆ #adbac7 ┆ p ┆ 6.0 │ |
| │ spark ┆ Spark ┆ #e25a1c ┆ * ┆ 7.0 │ |
| │ vaex ┆ Vaex ┆ #585858 ┆ v ┆ 6.0 │ |
| └──────────┴──────────┴─────────┴───────┴──────┘ |
| """ |
| ) |
|
|
| return all_styles.filter(~pl.col("solution").is_in(exclude_solutions)) |
|
|
|
|
| def parse_queries(s: str) -> list[str]: |
| int_set = set() |
| for part in s.split(","): |
| if "-" in part: |
| start, end = map(int, part.split("-")) |
| int_set.update(range(start, end + 1)) |
| else: |
| int_set.add(int(part)) |
| return [f"q{x}" for x in sorted(list(int_set))] |
|
|
|
|
| def read_csv(filename: str) -> pl.DataFrame: |
| if filename == "-": |
| df = pl.read_csv(sys.stdin.buffer) |
| else: |
| df = pl.read_csv(filename) |
| return df |
|
|
|
|
| def prepare_timings( |
| timings: pl.DataFrame, |
| styles: pl.DataFrame, |
| exclude_solutions: list[str], |
| queries: list[str], |
| include_io: bool, |
| ): |
| return ( |
| timings.join(styles, on="solution", how="left") |
| .filter( |
| pl.col("success") |
| & pl.col("query_no").is_in(queries) |
| & (pl.col("include_io") == include_io) |
| & ~pl.col("solution").is_in(exclude_solutions) |
| ) |
| .select( |
| pl.col("solution"), |
| pl.col("name"), |
| (pl.col("name") + " (" + pl.col("version") + ")").alias("name_version"), |
| pl.col("query_no").alias("query"), |
| pl.col("duration[s]").alias("duration"), |
| ) |
| ) |
|
|
|
|
| def formulate_caption( |
| timings: pl.DataFrame, |
| styles: pl.DataFrame, |
| queries: list[str], |
| no_notes: bool, |
| max_duration: float, |
| width: float, |
| ): |
| caption = "" |
|
|
| if not no_notes: |
| exceeded_timings = timings.filter(pl.col("duration") > max_duration).select( |
| pl.col("name"), |
| pl.col("query"), |
| ( |
| pl.lit("took ") |
| + pl.col("duration").round(1).cast(pl.Utf8) |
| + "s on " |
| + pl.col("query") |
| ).alias("text"), |
| ) |
|
|
| all_combinations_df = styles.select("name").join( |
| pl.DataFrame({"query": queries}), how="cross" |
| ) |
|
|
| missing_timings = all_combinations_df.join( |
| timings, how="anti", on=["name", "query"] |
| ).with_columns((pl.lit("failed on ") + pl.col("query")).alias("text")) |
|
|
| notes_df = pl.concat([exceeded_timings, missing_timings]).sort( |
| pl.col("name"), pl.col("query").str.slice(1).cast(pl.Int8) |
| ) |
|
|
| notes = [] |
| for name, group in notes_df.group_by("name"): |
| texts = group.get_column("text") |
| join_char = ", " if len(texts) >= 3 else " " |
|
|
| if len(texts) >= 2: |
| texts[-1] = "and " + texts[-1] |
|
|
| notes.append(f"{name} {join_char.join(texts)}.") |
|
|
| if notes: |
| caption += f"Note: {' '.join(notes)} " |
| caption += "More information: https://www.pola.rs/benchmarks.html" |
| return "\n".join(textwrap.wrap(caption, int(width * 15 - 20))) |
|
|
|
|
| def create_plot( |
| timings: pl.DataFrame, |
| styles: pl.DataFrame, |
| queries: list[str], |
| caption: str, |
| args: argparse.Namespace, |
| ) -> None: |
| if args.include_io: |
| subtitle = "Results including reading parquet (lower is better)" |
| else: |
| subtitle = "Results starting from in-memory data (lower is better)" |
|
|
| theme = { |
| "dark": { |
| "background_color": "#0d1117", |
| "text_color": "#adbac7", |
| "line_color": "#999", |
| }, |
| "light": { |
| "background_color": "#fff", |
| "text_color": "#333", |
| "line_color": "#999", |
| }, |
| } |
|
|
| styles = styles.join(timings, on="solution", how="semi") |
|
|
| plot = ( |
| p9.ggplot( |
| timings, |
| p9.aes( |
| x="duration", |
| y="query", |
| fill="name_version", |
| shape="name_version", |
| size="name_version", |
| ), |
| ) |
| + p9.geom_point(alpha=1, color="black") |
| + p9.scale_x_continuous(limits=(0, args.max_duration)) |
| + p9.scale_y_discrete(limits=queries[::-1]) |
| + p9.scale_fill_manual(values=styles.get_column("color")) |
| + p9.scale_shape_manual(values=styles.get_column("shape")) |
| + p9.scale_size_manual(values=styles.get_column("size")) |
| + p9.labs( |
| title="TPCH Benchmark", |
| subtitle=subtitle, |
| caption=caption, |
| x="duration (s)", |
| ) |
| + p9.theme_tufte(ticks=False) |
| + p9.theme( |
| text=p9.element_text(color=theme[args.mode]["text_color"]), |
| plot_title=p9.element_text(size=18, weight=800), |
| panel_grid_major_y=p9.element_line(color=theme[args.mode]["line_color"]), |
| legend_title=p9.element_blank(), |
| plot_subtitle=p9.element_text(margin={"b": 20}), |
| plot_caption=p9.element_text( |
| ha="left", linespacing=2, style="italic", margin={"t": 20} |
| ), |
| figure_size=(args.width, args.height), |
| dpi=args.dpi, |
| ) |
| ) |
|
|
| if not args.transparent: |
| plot = plot + p9.theme( |
| plot_background=p9.element_rect( |
| color=theme[args.mode]["background_color"], |
| fill=theme[args.mode]["background_color"], |
| ) |
| ) |
|
|
| return plot |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description="Create dot plot from timings CSV file.", |
| formatter_class=argparse.ArgumentDefaultsHelpFormatter, |
| ) |
| parser.add_argument( |
| "csv", |
| nargs="?", |
| default="-", |
| metavar="<csv file>", |
| help="CSV file to read (if not specified, reads from stdin)", |
| ) |
| parser.add_argument( |
| "-d", |
| "--max-duration", |
| type=float, |
| default=4.0, |
| help="Maximum duration", |
| metavar="<seconds>", |
| ) |
| parser.add_argument( |
| "-q", |
| "--queries", |
| type=str, |
| default="1-8", |
| help="Queries to include", |
| metavar="<integers and ranges>", |
| ) |
| parser.add_argument( |
| "-e", |
| "--exclude", |
| type=str, |
| default="", |
| help="Solutions to exclude", |
| metavar="<list of solutions>", |
| ) |
| parser.add_argument( |
| "-i", |
| "--include-io", |
| action="store_true", |
| help="Include I/O time", |
| ) |
| parser.add_argument( |
| "-n", |
| "--no-notes", |
| action="store_true", |
| help="Don't include failed or exceeded timings in caption", |
| ) |
| parser.add_argument( |
| "-m", |
| "--mode", |
| type=str, |
| choices=["dark", "light"], |
| default="dark", |
| help="Theme mode", |
| ) |
| parser.add_argument( |
| "-t", |
| "--transparent", |
| action="store_true", |
| help="Make figure background transparent", |
| ) |
| parser.add_argument( |
| "--width", |
| type=float, |
| default=8.0, |
| help="Figure width", |
| metavar="<inch>", |
| ) |
| parser.add_argument( |
| "--height", |
| type=float, |
| default=4.0, |
| help="Figure height", |
| metavar="<inch>", |
| ) |
| parser.add_argument( |
| "--dpi", |
| type=float, |
| default=200, |
| help="Figure DPI", |
| metavar="<dpi>", |
| ) |
| parser.add_argument( |
| "-o", |
| "--output", |
| type=str, |
| default="plot.png", |
| help="Output file", |
| metavar="<png file>", |
| ) |
|
|
| args = parser.parse_args() |
|
|
| exclude_solutions = args.exclude.split(",") |
| styles = get_styles(exclude_solutions) |
| queries = parse_queries(args.queries) |
| timings = prepare_timings( |
| read_csv(args.csv), styles, exclude_solutions, queries, args.include_io |
| ) |
| caption = formulate_caption( |
| timings, styles, queries, args.no_notes, args.max_duration, args.width |
| ) |
|
|
| plot = create_plot(timings, styles, queries, caption, args) |
|
|
| plot.save(args.output) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
