react-code-dataset / next.js /turbopack /xtask /src /visualize_bundler_bench.rs

Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

12 kB

use std::{
    collections::BTreeMap,
    fs::{self, File},
    io::BufReader,
    path::PathBuf,
    str::FromStr,
};

use anyhow::{Context, Result};
use num_format::{Locale, ToFormattedString};
use plotters::{
    backend::SVGBackend,
    data::fitting_range,
    prelude::{BindKeyPoints, ChartBuilder, IntoDrawingArea, PathElement, SeriesLabelPosition},
    series::LineSeries,
    style::{Color, RGBAColor, RGBColor},
};
use rustc_hash::FxHashSet;

use crate::summarize_bench::data::{BaseBenchmarks, CStats};

type ByModuleCount = BTreeMap<u32, CStats>;
type ByBundler = BTreeMap<Bundler, ByModuleCount>;
type ByBench = BTreeMap<String, ByBundler>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Bundler {
    NextJs11Ssr,
    NextJs12Ssr,
    ViteCsr,
    ViteSsr,
    ViteSwcCsr,
    NextJs13Ssr,
    NextJs13Rsc,
    NextJs13Rcc,
    TurbopackCsr,
    TurbopackSsr,
    TurbopackRsc,
    TurbopackRcc,
    Webpack,
    Parcel,
}

impl std::fmt::Display for Bundler {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl FromStr for Bundler {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "Next.js 11 SSR" => Ok(Self::NextJs11Ssr),
            "Next.js 12 SSR" => Ok(Self::NextJs12Ssr),
            "Next.js 13 SSR" => Ok(Self::NextJs13Ssr),
            "Next.js 13 RSC" => Ok(Self::NextJs13Rsc),
            "Next.js 13 RCC" => Ok(Self::NextJs13Rcc),
            "Turbopack CSR" => Ok(Self::TurbopackCsr),
            "Turbopack SSR" => Ok(Self::TurbopackSsr),
            "Turbopack RSC" => Ok(Self::TurbopackRsc),
            "Turbopack RCC" => Ok(Self::TurbopackRcc),
            "Vite CSR" => Ok(Self::ViteCsr),
            "Vite SSR" => Ok(Self::ViteSsr),
            "Vite SWC CSR" => Ok(Self::ViteSwcCsr),
            "Webpack" => Ok(Self::Webpack),
            "Parcel" => Ok(Self::Parcel),
            _ => Err(()),
        }
    }
}

impl Bundler {
    fn as_str(&self) -> &'static str {
        match self {
            Self::NextJs11Ssr => "Next.js 11 SSR",
            Self::NextJs12Ssr => "Next.js 12 SSR",
            Self::NextJs13Ssr => "Next.js 13 SSR",
            Self::NextJs13Rsc => "Next.js 13 RSC",
            Self::NextJs13Rcc => "Next.js 13 RCC",
            Self::TurbopackCsr => "Turbopack CSR",
            Self::TurbopackSsr => "Turbopack SSR",
            Self::TurbopackRsc => "Turbopack RSC",
            Self::TurbopackRcc => "Turbopack RCC",
            Self::ViteCsr => "Vite CSR",
            Self::ViteSsr => "Vite SSR",
            Self::ViteSwcCsr => "Vite SWC CSR",
            Self::Webpack => "Webpack",
            Self::Parcel => "Parcel",
        }
    }

    fn color(&self) -> RGBColor {
        match self {
            // These are the currently used ones.
            Self::NextJs12Ssr => plotters::style::full_palette::CYAN,
            Self::NextJs11Ssr => plotters::style::full_palette::BLUE,

            Self::TurbopackSsr => plotters::style::full_palette::RED,
            Self::ViteSwcCsr => plotters::style::full_palette::GREEN,

            // TODO(alexkirsz) These should probably change to be consistent with the above.
            Self::NextJs13Ssr => plotters::style::full_palette::PURPLE,
            Self::NextJs13Rsc => plotters::style::full_palette::PURPLE_300,
            Self::NextJs13Rcc => plotters::style::full_palette::PURPLE_700,

            Self::TurbopackCsr => plotters::style::full_palette::RED_200,
            Self::TurbopackRsc => plotters::style::full_palette::RED_300,
            Self::TurbopackRcc => plotters::style::full_palette::RED_700,

            Self::ViteCsr => plotters::style::full_palette::GREEN_200,
            Self::ViteSsr => plotters::style::full_palette::GREEN_300,

            Self::Webpack => plotters::style::full_palette::YELLOW,
            Self::Parcel => plotters::style::full_palette::BROWN,
        }
    }
}

pub fn generate(summary_path: PathBuf, filter_bundlers: Option<FxHashSet<&str>>) -> Result<()> {
    let summary_file = File::open(&summary_path)?;
    let reader = BufReader::new(summary_file);
    let summary: BaseBenchmarks = serde_json::from_reader(reader)?;

    let mut by_bench: ByBench = BTreeMap::new();
    for (_, bench) in summary.benchmarks {
        // TODO: Improve heuristic for detecting bundler benchmarks
        if !bench.info.group_id.starts_with("bench_") {
            continue;
        }

        let Some(function_id) = bench.info.function_id else {
            continue;
        };

        let Ok(bundler) = Bundler::from_str(&function_id) else {
            eprintln!("Skipping benchmark with unknown bundler: {function_id}");
            continue;
        };

        if filter_bundlers
            .as_ref()
            .map(|bundlers| !bundlers.contains(bundler.as_str()))
            .unwrap_or(false)
        {
            continue;
        }

        let by_bundler = by_bench.entry(bench.info.group_id).or_default();

        let by_module_count = by_bundler.entry(bundler).or_default();

        by_module_count.insert(
            bench
                .info
                .value_str
                .context("Missing value_str")?
                .split_ascii_whitespace()
                .collect::<Vec<&str>>()[0]
                .parse()?,
            // we want to use slope instead of mean when available since this is a better
            // estimation of the real performance values when iterations go to infinity
            bench.estimates.slope.unwrap_or(bench.estimates.mean),
        );
    }

    let output_path = summary_path.parent().context("summary_path needs parent")?;
    generate_scaling(output_path.join("scaling"), &by_bench)?;

    Ok(())
}

#[derive(Debug, Clone, Copy)]
enum FormatTimeStyle {
    Milliseconds,
    Seconds,
}

impl FormatTimeStyle {
    fn format(self, ns: f64) -> String {
        let value = (match self {
            FormatTimeStyle::Milliseconds => ns / 1e6,
            FormatTimeStyle::Seconds => ns / 1e9,
        }
        .round() as u64)
            .to_formatted_string(&Locale::en);

        format!("{}{}", value, self.unit())
    }

    fn unit(self) -> &'static str {
        match self {
            FormatTimeStyle::Milliseconds => "ms",
            FormatTimeStyle::Seconds => "s",
        }
    }
}

#[derive(Debug, Clone, Copy)]
enum Theme {
    Light,
    Dark,
}

impl Theme {
    fn name(self) -> &'static str {
        match self {
            Theme::Light => "light",
            Theme::Dark => "dark",
        }
    }

    fn legend_background_color(self) -> RGBAColor {
        match self {
            Theme::Light => plotters::style::colors::WHITE.into(),
            Theme::Dark => RGBColor(34, 34, 34).into(),
        }
    }

    fn light_line_color(self) -> RGBAColor {
        match self {
            Theme::Light => plotters::style::colors::BLACK.mix(0.1),
            Theme::Dark => plotters::style::colors::WHITE.mix(0.1),
        }
    }

    fn bold_line_color(self) -> RGBAColor {
        match self {
            Theme::Light => plotters::style::colors::BLACK.mix(0.2),
            Theme::Dark => plotters::style::colors::WHITE.mix(0.2),
        }
    }

    fn axis_line_color(self) -> RGBAColor {
        match self {
            Theme::Light => plotters::style::colors::BLACK.into(),
            Theme::Dark => plotters::style::colors::WHITE.into(),
        }
    }

    fn label_color(self) -> RGBAColor {
        match self {
            Theme::Light => plotters::style::colors::BLACK.mix(0.75),
            Theme::Dark => plotters::style::colors::WHITE.mix(0.75),
        }
    }

    fn axis_desc_color(self) -> RGBAColor {
        match self {
            Theme::Light => plotters::style::colors::BLACK.into(),
            Theme::Dark => plotters::style::colors::WHITE.into(),
        }
    }
}

const THEMES: [Theme; 2] = [Theme::Light, Theme::Dark];

fn generate_scaling(output_path: PathBuf, by_bench: &ByBench) -> Result<()> {
    fs::create_dir_all(&output_path)?;

    for theme in THEMES {
        for (bench_name, by_bundler) in by_bench {
            let module_counts: FxHashSet<_> = by_bundler
                .values()
                .flat_map(|by_module_count| by_module_count.keys())
                .copied()
                .collect();
            let module_count_range = fitting_range(module_counts.iter());

            // Ensure we have labels for every sampled module count.
            let module_count_range =
                module_count_range.with_key_points(module_counts.into_iter().collect());

            let time_range_iter = by_bundler.values().flat_map(|by_module_count| {
                by_module_count.values().map(|stats| stats.point_estimate)
            });

            // Make the time range end 5% higher than the maximum time value so the highest
            // point is not cut off.
            let time_range_end = time_range_iter
                // f64 does not implement Ord.
                .fold(0.0, |max, time| if time > max { time } else { max })
                * 1.05;
            // Ensure the time range starts at 0 instead of the minimum time value.
            let time_range = 0.0..time_range_end;

            let format_time_style = if time_range.end > 10e8 {
                FormatTimeStyle::Seconds
            } else {
                FormatTimeStyle::Milliseconds
            };

            let file_name = output_path.join(format!("{}_{}.svg", bench_name, theme.name()));
            let root = SVGBackend::new(&file_name, (960, 720)).into_drawing_area();
            let mut chart = ChartBuilder::on(&root)
                .x_label_area_size(60)
                // The y labels are horizontal and have units, so they take some room.
                .y_label_area_size(80)
                .margin(30)
                .build_cartesian_2d(module_count_range, time_range)?;

            for (bundler, by_module_count) in by_bundler.iter() {
                let color = bundler.color();
                let points = by_module_count
                    .iter()
                    .map(|(count, stats)| (count.to_owned(), stats.point_estimate));

                chart
                    .draw_series(LineSeries::new(points.clone(), color.stroke_width(4)))?
                    .label(bundler.as_str())
                    .legend(move |(x, y)| {
                        PathElement::new(vec![(x, y), (x + 20, y)], color.stroke_width(4))
                    });
            }

            // This is the font used by the turbo.build website.
            let font = r#"ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji""#;

            chart
                .configure_mesh()
                .x_labels(10)
                .y_labels(10)
                .x_desc("Number of modules")
                .y_desc("Mean time — lower is better")
                .x_label_style((font, 20, &theme.label_color()))
                .y_label_style((font, 20, &theme.label_color()))
                .axis_desc_style((font, 24, &theme.axis_desc_color()))
                .x_label_formatter(&|v| v.to_formatted_string(&Locale::en))
                .y_label_formatter(&|v| format_time_style.format(*v))
                .bold_line_style(theme.bold_line_color())
                .light_line_style(theme.light_line_color())
                .axis_style(theme.axis_line_color())
                .draw()?;

            chart
                .configure_series_labels()
                .background_style(theme.legend_background_color())
                .border_style(theme.bold_line_color())
                .label_font((font, 20, &theme.axis_desc_color()))
                .position(SeriesLabelPosition::UpperLeft)
                .margin(16)
                .draw()?;

            root.present()?;
        }
    }

    Ok(())
}

	use std::{
	collections::BTreeMap,
	fs::{self, File},
	io::BufReader,
	path::PathBuf,
	str::FromStr,
	};

	use anyhow::{Context, Result};
	use num_format::{Locale, ToFormattedString};
	use plotters::{
	backend::SVGBackend,
	data::fitting_range,
	prelude::{BindKeyPoints, ChartBuilder, IntoDrawingArea, PathElement, SeriesLabelPosition},
	series::LineSeries,
	style::{Color, RGBAColor, RGBColor},
	};
	use rustc_hash::FxHashSet;

	use crate::summarize_bench::data::{BaseBenchmarks, CStats};

	type ByModuleCount = BTreeMap<u32, CStats>;
	type ByBundler = BTreeMap<Bundler, ByModuleCount>;
	type ByBench = BTreeMap<String, ByBundler>;

	#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
	enum Bundler {
	NextJs11Ssr,
	NextJs12Ssr,
	ViteCsr,
	ViteSsr,
	ViteSwcCsr,
	NextJs13Ssr,
	NextJs13Rsc,
	NextJs13Rcc,
	TurbopackCsr,
	TurbopackSsr,
	TurbopackRsc,
	TurbopackRcc,
	Webpack,
	Parcel,
	}

	impl std::fmt::Display for Bundler {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	write!(f, "{}", self.as_str())
	}
	}

	impl FromStr for Bundler {
	type Err = ();

	fn from_str(s: &str) -> Result<Self, Self::Err> {
	match s {
	"Next.js 11 SSR" => Ok(Self::NextJs11Ssr),
	"Next.js 12 SSR" => Ok(Self::NextJs12Ssr),
	"Next.js 13 SSR" => Ok(Self::NextJs13Ssr),
	"Next.js 13 RSC" => Ok(Self::NextJs13Rsc),
	"Next.js 13 RCC" => Ok(Self::NextJs13Rcc),
	"Turbopack CSR" => Ok(Self::TurbopackCsr),
	"Turbopack SSR" => Ok(Self::TurbopackSsr),
	"Turbopack RSC" => Ok(Self::TurbopackRsc),
	"Turbopack RCC" => Ok(Self::TurbopackRcc),
	"Vite CSR" => Ok(Self::ViteCsr),
	"Vite SSR" => Ok(Self::ViteSsr),
	"Vite SWC CSR" => Ok(Self::ViteSwcCsr),
	"Webpack" => Ok(Self::Webpack),
	"Parcel" => Ok(Self::Parcel),
	_ => Err(()),
	}
	}
	}

	impl Bundler {
	fn as_str(&self) -> &'static str {
	match self {
	Self::NextJs11Ssr => "Next.js 11 SSR",
	Self::NextJs12Ssr => "Next.js 12 SSR",
	Self::NextJs13Ssr => "Next.js 13 SSR",
	Self::NextJs13Rsc => "Next.js 13 RSC",
	Self::NextJs13Rcc => "Next.js 13 RCC",
	Self::TurbopackCsr => "Turbopack CSR",
	Self::TurbopackSsr => "Turbopack SSR",
	Self::TurbopackRsc => "Turbopack RSC",
	Self::TurbopackRcc => "Turbopack RCC",
	Self::ViteCsr => "Vite CSR",
	Self::ViteSsr => "Vite SSR",
	Self::ViteSwcCsr => "Vite SWC CSR",
	Self::Webpack => "Webpack",
	Self::Parcel => "Parcel",
	}
	}

	fn color(&self) -> RGBColor {
	match self {
	// These are the currently used ones.
	Self::NextJs12Ssr => plotters::style::full_palette::CYAN,
	Self::NextJs11Ssr => plotters::style::full_palette::BLUE,

	Self::TurbopackSsr => plotters::style::full_palette::RED,
	Self::ViteSwcCsr => plotters::style::full_palette::GREEN,

	// TODO(alexkirsz) These should probably change to be consistent with the above.
	Self::NextJs13Ssr => plotters::style::full_palette::PURPLE,
	Self::NextJs13Rsc => plotters::style::full_palette::PURPLE_300,
	Self::NextJs13Rcc => plotters::style::full_palette::PURPLE_700,

	Self::TurbopackCsr => plotters::style::full_palette::RED_200,
	Self::TurbopackRsc => plotters::style::full_palette::RED_300,
	Self::TurbopackRcc => plotters::style::full_palette::RED_700,

	Self::ViteCsr => plotters::style::full_palette::GREEN_200,
	Self::ViteSsr => plotters::style::full_palette::GREEN_300,

	Self::Webpack => plotters::style::full_palette::YELLOW,
	Self::Parcel => plotters::style::full_palette::BROWN,
	}
	}
	}

	pub fn generate(summary_path: PathBuf, filter_bundlers: Option<FxHashSet<&str>>) -> Result<()> {
	let summary_file = File::open(&summary_path)?;
	let reader = BufReader::new(summary_file);
	let summary: BaseBenchmarks = serde_json::from_reader(reader)?;

	let mut by_bench: ByBench = BTreeMap::new();
	for (_, bench) in summary.benchmarks {
	// TODO: Improve heuristic for detecting bundler benchmarks
	if !bench.info.group_id.starts_with("bench_") {
	continue;
	}

	let Some(function_id) = bench.info.function_id else {
	continue;
	};

	let Ok(bundler) = Bundler::from_str(&function_id) else {
	eprintln!("Skipping benchmark with unknown bundler: {function_id}");
	continue;
	};

	if filter_bundlers
	.as_ref()
	.map(\|bundlers\| !bundlers.contains(bundler.as_str()))
	.unwrap_or(false)
	{
	continue;
	}

	let by_bundler = by_bench.entry(bench.info.group_id).or_default();

	let by_module_count = by_bundler.entry(bundler).or_default();

	by_module_count.insert(
	bench
	.info
	.value_str
	.context("Missing value_str")?
	.split_ascii_whitespace()
	.collect::<Vec<&str>>()[0]
	.parse()?,
	// we want to use slope instead of mean when available since this is a better
	// estimation of the real performance values when iterations go to infinity
	bench.estimates.slope.unwrap_or(bench.estimates.mean),
	);
	}

	let output_path = summary_path.parent().context("summary_path needs parent")?;
	generate_scaling(output_path.join("scaling"), &by_bench)?;

	Ok(())
	}

	#[derive(Debug, Clone, Copy)]
	enum FormatTimeStyle {
	Milliseconds,
	Seconds,
	}

	impl FormatTimeStyle {
	fn format(self, ns: f64) -> String {
	let value = (match self {
	FormatTimeStyle::Milliseconds => ns / 1e6,
	FormatTimeStyle::Seconds => ns / 1e9,
	}
	.round() as u64)
	.to_formatted_string(&Locale::en);

	format!("{}{}", value, self.unit())
	}

	fn unit(self) -> &'static str {
	match self {
	FormatTimeStyle::Milliseconds => "ms",
	FormatTimeStyle::Seconds => "s",
	}
	}
	}

	#[derive(Debug, Clone, Copy)]
	enum Theme {
	Light,
	Dark,
	}

	impl Theme {
	fn name(self) -> &'static str {
	match self {
	Theme::Light => "light",
	Theme::Dark => "dark",
	}
	}

	fn legend_background_color(self) -> RGBAColor {
	match self {
	Theme::Light => plotters::style::colors::WHITE.into(),
	Theme::Dark => RGBColor(34, 34, 34).into(),
	}
	}

	fn light_line_color(self) -> RGBAColor {
	match self {
	Theme::Light => plotters::style::colors::BLACK.mix(0.1),
	Theme::Dark => plotters::style::colors::WHITE.mix(0.1),
	}
	}

	fn bold_line_color(self) -> RGBAColor {
	match self {
	Theme::Light => plotters::style::colors::BLACK.mix(0.2),
	Theme::Dark => plotters::style::colors::WHITE.mix(0.2),
	}
	}

	fn axis_line_color(self) -> RGBAColor {
	match self {
	Theme::Light => plotters::style::colors::BLACK.into(),
	Theme::Dark => plotters::style::colors::WHITE.into(),
	}
	}

	fn label_color(self) -> RGBAColor {
	match self {
	Theme::Light => plotters::style::colors::BLACK.mix(0.75),
	Theme::Dark => plotters::style::colors::WHITE.mix(0.75),
	}
	}

	fn axis_desc_color(self) -> RGBAColor {
	match self {
	Theme::Light => plotters::style::colors::BLACK.into(),
	Theme::Dark => plotters::style::colors::WHITE.into(),
	}
	}
	}

	const THEMES: [Theme; 2] = [Theme::Light, Theme::Dark];

	fn generate_scaling(output_path: PathBuf, by_bench: &ByBench) -> Result<()> {
	fs::create_dir_all(&output_path)?;

	for theme in THEMES {
	for (bench_name, by_bundler) in by_bench {
	let module_counts: FxHashSet<_> = by_bundler
	.values()
	.flat_map(\|by_module_count\| by_module_count.keys())
	.copied()
	.collect();
	let module_count_range = fitting_range(module_counts.iter());

	// Ensure we have labels for every sampled module count.
	let module_count_range =
	module_count_range.with_key_points(module_counts.into_iter().collect());

	let time_range_iter = by_bundler.values().flat_map(\|by_module_count\| {
	by_module_count.values().map(\|stats\| stats.point_estimate)
	});

	// Make the time range end 5% higher than the maximum time value so the highest
	// point is not cut off.
	let time_range_end = time_range_iter
	// f64 does not implement Ord.
	.fold(0.0, \|max, time\| if time > max { time } else { max })
	* 1.05;
	// Ensure the time range starts at 0 instead of the minimum time value.
	let time_range = 0.0..time_range_end;

	let format_time_style = if time_range.end > 10e8 {
	FormatTimeStyle::Seconds
	} else {
	FormatTimeStyle::Milliseconds
	};

	let file_name = output_path.join(format!("{}_{}.svg", bench_name, theme.name()));
	let root = SVGBackend::new(&file_name, (960, 720)).into_drawing_area();
	let mut chart = ChartBuilder::on(&root)
	.x_label_area_size(60)
	// The y labels are horizontal and have units, so they take some room.
	.y_label_area_size(80)
	.margin(30)
	.build_cartesian_2d(module_count_range, time_range)?;

	for (bundler, by_module_count) in by_bundler.iter() {
	let color = bundler.color();
	let points = by_module_count
	.iter()
	.map(\|(count, stats)\| (count.to_owned(), stats.point_estimate));

	chart
	.draw_series(LineSeries::new(points.clone(), color.stroke_width(4)))?
	.label(bundler.as_str())
	.legend(move \|(x, y)\| {
	PathElement::new(vec![(x, y), (x + 20, y)], color.stroke_width(4))
	});
	}

	// This is the font used by the turbo.build website.
	let font = r#"ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji""#;

	chart
	.configure_mesh()
	.x_labels(10)
	.y_labels(10)
	.x_desc("Number of modules")
	.y_desc("Mean time — lower is better")
	.x_label_style((font, 20, &theme.label_color()))
	.y_label_style((font, 20, &theme.label_color()))
	.axis_desc_style((font, 24, &theme.axis_desc_color()))
	.x_label_formatter(&\|v\| v.to_formatted_string(&Locale::en))
	.y_label_formatter(&\|v\| format_time_style.format(*v))
	.bold_line_style(theme.bold_line_color())
	.light_line_style(theme.light_line_color())
	.axis_style(theme.axis_line_color())
	.draw()?;

	chart
	.configure_series_labels()
	.background_style(theme.legend_background_color())
	.border_style(theme.bold_line_color())
	.label_font((font, 20, &theme.axis_desc_color()))
	.position(SeriesLabelPosition::UpperLeft)
	.margin(16)
	.draw()?;

	root.present()?;
	}
	}

	Ok(())
	}