Upload folder using huggingface_hub

1e92f2d verified 6 months ago

14.9 kB

	use std::{
	cell::RefCell,
	fs::{create_dir_all, write},
	mem::forget,
	path::{Path, PathBuf},
	process::Command,
	sync::Arc,
	time::{Duration, Instant},
	};

	use anyhow::{Context, Result};
	use next_api::{
	project::{DefineEnv, DraftModeOptions, ProjectContainer, ProjectOptions, WatchOptions},
	register,
	route::endpoint_write_to_disk,
	};
	use serde_json::json;
	use tempfile::TempDir;
	use tokio::runtime::Runtime;
	use turbo_rcstr::RcStr;
	use turbo_tasks::{
	TransientInstance, TurboTasks, TurboTasksApi, Vc, backend::Backend, trace::TraceRawVcs,
	};
	use turbo_tasks_backend::noop_backing_storage;

	pub struct HmrBenchmark {
	test_app: TestApp,
	project_container: Vc<ProjectContainer>,
	}

	#[derive(Debug)]
	pub struct TestApp {
	_path: PathBuf,
	/// Prevent temp directory from being dropped
	_dir: TempDir,
	modules: Vec<(PathBuf, usize)>,
	}

	impl TestApp {
	pub fn path(&self) -> &Path {
	&self._path
	}

	pub fn modules(&self) -> &[(PathBuf, usize)] {
	&self.modules
	}
	}

	fn create_test_app(module_count: usize) -> Result<TestApp> {
	let temp_dir = tempfile::tempdir().context("Failed to create temp directory")?;
	let base_path = temp_dir.path().to_path_buf();

	// Create basic Next.js structure
	let pages_dir = base_path.join("pages");
	let app_dir = base_path.join("app");
	let src_dir = base_path.join("src");

	create_dir_all(&pages_dir)?;
	create_dir_all(&app_dir)?;
	create_dir_all(&src_dir)?;

	let mut modules = Vec::new();

	// Create index page
	let index_content = r#"import React from 'react';

	export default function Home() {
	return <div>Hello World</div>;
	}
	"#;
	let index_path = pages_dir.join("index.js");
	write(&index_path, index_content)?;
	modules.push((index_path, 0));

	// Create app layout
	let layout_content = r#"export default function RootLayout({ children }) {
	return (
	<html>
	<body>{children}</body>
	</html>
	);
	}
	"#;
	let layout_path = app_dir.join("layout.js");
	write(&layout_path, layout_content)?;
	modules.push((layout_path, 0));

	// Create app page
	let app_page_content = r#"export default function Page() {
	return <div>App Router Page</div>;
	}
	"#;
	let app_page_path = app_dir.join("page.js");
	write(&app_page_path, app_page_content)?;
	modules.push((app_page_path, 0));

	// Create additional modules based on module_count
	for i in 3..module_count {
	let component_content = format!(
	r#"import React from 'react';

	export default function Component{i}() {{
	return <div>Component {i}</div>;
	}}
	"#
	);

	let component_path = src_dir.join(format!("component{i}.js"));
	write(&component_path, component_content)?;
	modules.push((component_path, 1));
	}

	// Create package.json
	let package_json = r#"{
	"name": "hmr-test-app",
	"version": "1.0.0",
	"dependencies": {
	"react": "^19.0.0",
	"react-dom": "^19.0.0",
	"next": "^15.0.0"
	}
	}
	"#;
	write(base_path.join("package.json"), package_json)?;

	// Create next.config.js
	let next_config = "module.exports = {}";
	write(base_path.join("next.config.js"), next_config)?;

	// Run `npm install`
	let output = Command::new("npm")
	.current_dir(&base_path)
	.args(["install"])
	.output()?;

	if !output.status.success() {
	return Err(anyhow::anyhow!("Failed to run `npm install`"));
	}

	Ok(TestApp {
	_path: base_path,
	_dir: temp_dir,
	modules,
	})
	}

	fn load_next_config() -> RcStr {
	serde_json::to_string(&json!({
	"sassOptions": {

	},
	}))
	.unwrap()
	.into()
	}

	fn runtime() -> Runtime {
	thread_local! {
	static LAST_SWC_ATOM_GC_TIME: RefCell<Option<Instant>> = const { RefCell::new(None) };
	}

	tokio::runtime::Builder::new_multi_thread()
	.enable_all()
	.on_thread_stop(\|\| {
	turbo_tasks_malloc::TurboMalloc::thread_stop();
	})
	.on_thread_park(\|\| {
	LAST_SWC_ATOM_GC_TIME.with_borrow_mut(\|cell\| {
	if cell.is_none_or(\|t\| t.elapsed() > Duration::from_secs(2)) {
	swc_core::ecma::atoms::hstr::global_atom_store_gc();
	*cell = Some(Instant::now());
	}
	});
	})
	.build()
	.context("Failed to build tokio runtime")
	.unwrap()
	}

	impl HmrBenchmark {
	pub async fn new(module_count: usize) -> Result<Self> {
	let test_app = create_test_app(module_count)?;

	let project_container = {
	let container = ProjectContainer::new(RcStr::from("hmr-benchmark"), true)
	.to_resolved()
	.await?;

	let project_path = test_app.path().to_string_lossy().to_string();
	let root_path = test_app.path().to_string_lossy().to_string();

	let options = ProjectOptions {
	root_path: RcStr::from(root_path),
	project_path: RcStr::from(project_path.clone()),
	next_config: load_next_config(),
	js_config: RcStr::from("{}"),
	env: vec![],
	define_env: DefineEnv {
	client: vec![],
	edge: vec![],
	nodejs: vec![],
	},
	watch: WatchOptions {
	enable: true,
	poll_interval: None,
	},
	dev: true,
	encryption_key: RcStr::from("test-key"),
	build_id: RcStr::from("development"),
	preview_props: DraftModeOptions {
	preview_mode_id: RcStr::from("development"),
	preview_mode_encryption_key: RcStr::from("test-key"),
	preview_mode_signing_key: RcStr::from("test-key"),
	},
	browserslist_query: RcStr::from("last 2 versions"),
	no_mangling: false,
	current_node_js_version: RcStr::from("18.0.0"),
	};

	container.initialize(options).await?;
	Ok::<_, anyhow::Error>(container)
	}?;

	Ok(Self {
	test_app,
	project_container: *project_container,
	})
	}

	/// Simulate file changes for HMR testing
	pub fn make_file_change(&self, file_path: &Path, change_id: usize) -> Result<()> {
	let mut content =
	std::fs::read_to_string(file_path).context("Failed to read file content")?;

	// Add a comment with a unique identifier to trigger HMR
	let change_marker = format!("// HMR_CHANGE_{change_id}\n");
	content.push_str(&change_marker);

	std::fs::write(file_path, content).context("Failed to write modified content")?;

	Ok(())
	}

	/// Benchmark HMR update detection and processing
	pub async fn benchmark_hmr_update(&self, num_updates: usize) -> Result<Duration> {
	// Get entrypoints to trigger initial compilation
	let entrypoints = self.project_container.entrypoints();
	let initial_result = entrypoints.await?;

	// Check if we have routes available
	if initial_result.routes.is_empty() {
	return Err(anyhow::anyhow!("No routes found in entrypoints"));
	}

	// Get HMR identifiers
	let hmr_identifiers = self.project_container.hmr_identifiers();
	let identifiers = hmr_identifiers.await?;

	if identifiers.is_empty() {
	return Err(anyhow::anyhow!("No HMR identifiers found"));
	}

	// Get project to access HMR methods
	let project = self.project_container.project();

	// Create multiple sessions to simulate real HMR usage
	let mut update_durations = Vec::new();

	for i in 0..num_updates {
	let update_start = Instant::now();

	// Use different identifiers for each update
	let identifier = &identifiers[i % identifiers.len()];

	// Get version state for this update
	let session = TransientInstance::new(());
	let version_state = project.hmr_version_state(identifier.clone(), session);

	// Pick a module file to change
	let module_index = i % self.test_app.modules().len();
	let (module_path, _) = &self.test_app.modules()[module_index];

	// Make a file change
	self.make_file_change(module_path, i)?;

	// Wait for HMR update and measure time
	let _update_result = project
	.hmr_update(identifier.clone(), version_state)
	.await?;

	update_durations.push(update_start.elapsed());
	}

	Ok(update_durations.iter().sum::<Duration>())
	}

	/// Benchmark HMR subscription and event handling
	pub async fn benchmark_hmr_subscription(&self) -> Result<Duration> {
	let start_time = Instant::now();

	// Get entrypoints first
	let entrypoints = self.project_container.entrypoints();
	let _initial_result = entrypoints.await?;

	// Get HMR identifiers
	let hmr_identifiers = self.project_container.hmr_identifiers();
	let identifiers = hmr_identifiers.await?;

	if identifiers.is_empty() {
	return Err(anyhow::anyhow!("No HMR identifiers found"));
	}

	let project = self.project_container.project();

	// Test subscription to multiple identifiers
	let mut version_states = Vec::new();
	for identifier in identifiers.iter().take(5) {
	// Test with first 5 identifiers
	let session = TransientInstance::new(());
	let version_state = project.hmr_version_state(identifier.clone(), session);
	version_states.push((identifier.clone(), version_state));
	}

	// Simulate multiple rapid updates
	for (i, (identifier, version_state)) in version_states.iter().enumerate() {
	// Make a file change
	if let Some((module_path, _)) = self.test_app.modules().get(i) {
	self.make_file_change(module_path, i * 100)?;

	// Check for update
	let _update_result = project
	.hmr_update(identifier.clone(), *version_state)
	.await?;
	}
	}

	Ok(start_time.elapsed())
	}

	/// Benchmark initial project setup and entrypoint detection
	pub async fn benchmark_initial_compilation(&self) -> Result<Duration> {
	let start_time = Instant::now();

	let entrypoints = self.project_container.entrypoints();
	let result = entrypoints.await?;

	for route in result.routes.values() {
	match route {
	next_api::route::Route::Page {
	html_endpoint,
	data_endpoint,
	} => {
	let _ = endpoint_write_to_disk(**html_endpoint).await?;
	let _ = endpoint_write_to_disk(**data_endpoint).await?;
	}
	next_api::route::Route::PageApi { endpoint } => {
	let _ = endpoint_write_to_disk(**endpoint).await?;
	}
	next_api::route::Route::AppPage(app_page_routes) => {
	for route in app_page_routes.iter() {
	let _ = endpoint_write_to_disk(*route.html_endpoint).await?;
	let _ = endpoint_write_to_disk(*route.rsc_endpoint).await?;
	}
	}
	next_api::route::Route::AppRoute { endpoint, .. } => {
	let _ = endpoint_write_to_disk(**endpoint).await?;
	}
	next_api::route::Route::Conflict => {}
	}
	}

	Ok(start_time.elapsed())
	}

	/// Get the number of modules in the test app
	pub fn module_count(&self) -> usize {
	self.test_app.modules().len()
	}
	}

	async fn setup_benchmark(module_count: usize) -> HmrBenchmark {
	register();
	HmrBenchmark::new(module_count).await.unwrap()
	}

	fn setup_runtime() -> Runtime {
	runtime()
	}

	fn setup_turbo_tasks() -> Arc<TurboTasks<impl Backend>> {
	TurboTasks::new(turbo_tasks_backend::TurboTasksBackend::new(
	turbo_tasks_backend::BackendOptions {
	storage_mode: None,
	dependency_tracking: true,
	..Default::default()
	},
	noop_backing_storage(),
	))
	}

	#[derive(TraceRawVcs)]
	struct Setup {
	#[turbo_tasks(trace_ignore)]
	rt: Arc<Runtime>,
	#[turbo_tasks(trace_ignore)]
	tt: Arc<dyn TurboTasksApi>,
	#[turbo_tasks(trace_ignore)]
	benchmark: HmrBenchmark,
	}

	fn setup_everything(module_count: usize) -> Arc<Setup> {
	let rt = Arc::new(setup_runtime());
	let tt = setup_turbo_tasks();

	let arc = rt.clone().block_on(async move {
	tt.clone()
	.run_once(async move {
	let benchmark = setup_benchmark(module_count).await;
	benchmark.benchmark_initial_compilation().await.unwrap();

	Ok(Arc::new(Setup { rt, tt, benchmark }))
	})
	.await
	.unwrap()
	});

	// I don't know why this is needed, but it is required to avoid dropping tokio runtime from
	// async scope
	forget(arc.clone());
	arc
	}

	fn bench_update(bencher: divan::Bencher, module_count: usize, num_updates: usize) {
	let s = setup_everything(module_count);

	bencher
	.with_inputs(\|\| {
	let setup = s.clone();

	setup.clone().rt.block_on(async move {
	setup.clone().tt.run_once(Box::pin(async move {
	let _ = setup
	.benchmark
	.benchmark_initial_compilation()
	.await
	.unwrap();
	Ok(())
	}));
	});

	s.clone()
	})
	.bench_values(\|setup\| {
	setup.clone().rt.block_on(async move {
	setup.clone().tt.run_once(Box::pin(async move {
	setup
	.benchmark
	.benchmark_hmr_update(num_updates)
	.await
	.unwrap();
	Ok(())
	}));
	})
	});
	}

	#[divan::bench(sample_size = 10000, max_time = 60)]
	fn hmr_updates_small_5(bencher: divan::Bencher) {
	bench_update(bencher, 100, 5);
	}

	#[divan::bench(sample_size = 10000, max_time = 60)]
	fn hmr_updates_medium_10(bencher: divan::Bencher) {
	bench_update(bencher, 200, 10);
	}

	#[divan::bench(sample_size = 10000, max_time = 60)]
	fn hmr_updates_large_20(bencher: divan::Bencher) {
	bench_update(bencher, 500, 20);
	}

	fn main() {
	divan::main();
	}