| use std::{cell::RefCell, cmp::Reverse, collections::hash_map::Entry, mem::take}; |
|
|
| use anyhow::Result; |
| use either::Either; |
| use rustc_hash::{FxHashMap, FxHashSet}; |
| use serde::{Deserialize, Serialize}; |
| use turbo_rcstr::RcStr; |
| use turbo_tasks::{ |
| NonLocalValue, ResolvedVc, TryJoinIterExt, ValueToString, Vc, trace::TraceRawVcs, |
| }; |
| use turbopack_core::{ |
| asset::Asset, |
| chunk::ChunkingType, |
| module::{Module, Modules}, |
| module_graph::{GraphTraversalAction, ModuleGraph}, |
| resolve::ExportUsage, |
| }; |
|
|
| #[derive(PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, NonLocalValue, Debug)] |
| pub struct ModuleReference { |
| pub index: usize, |
| pub chunking_type: ChunkingType, |
| pub export: ExportUsage, |
| } |
|
|
| #[derive(PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, NonLocalValue, Debug)] |
| pub struct ModuleInfo { |
| pub ident: RcStr, |
| pub path: RcStr, |
| pub depth: u32, |
| pub size: u32, |
| |
| pub retained_size: u32, |
| pub references: Vec<ModuleReference>, |
| pub incoming_references: Vec<ModuleReference>, |
| } |
|
|
| #[turbo_tasks::value] |
| pub struct ModuleGraphSnapshot { |
| pub modules: Vec<ModuleInfo>, |
| pub entries: Vec<usize>, |
| } |
|
|
| #[turbo_tasks::function] |
| pub async fn get_module_graph_snapshot( |
| module_graph: Vc<ModuleGraph>, |
| entry_modules: Option<Vc<Modules>>, |
| ) -> Result<Vc<ModuleGraphSnapshot>> { |
| let module_graph = module_graph.await?; |
|
|
| struct RawModuleInfo { |
| module: ResolvedVc<Box<dyn Module>>, |
| depth: u32, |
| retained_modules: RefCell<FxHashSet<u32>>, |
| references: Vec<ModuleReference>, |
| incoming_references: Vec<ModuleReference>, |
| } |
|
|
| let mut entries = Vec::new(); |
| let mut modules = Vec::new(); |
| let mut module_to_index = FxHashMap::default(); |
|
|
| fn get_or_create_module( |
| modules: &mut Vec<RawModuleInfo>, |
| module_to_index: &mut FxHashMap<ResolvedVc<Box<dyn Module>>, usize>, |
| module: ResolvedVc<Box<dyn Module>>, |
| ) -> usize { |
| match module_to_index.entry(module) { |
| Entry::Occupied(entry) => *entry.get(), |
| Entry::Vacant(entry) => { |
| let index = modules.len(); |
| modules.push(RawModuleInfo { |
| module, |
| depth: u32::MAX, |
| references: Vec::new(), |
| incoming_references: Vec::new(), |
| retained_modules: Default::default(), |
| }); |
| entry.insert(index); |
| index |
| } |
| } |
| } |
|
|
| let entry_modules = if let Some(entry_modules) = entry_modules { |
| Either::Left(entry_modules.await?) |
| } else { |
| Either::Right(module_graph.entries().await?) |
| }; |
| module_graph |
| .traverse_edges_from_entries_bfs(entry_modules.iter().copied(), |parent_info, node| { |
| let module = node.module; |
| let module_index = get_or_create_module(&mut modules, &mut module_to_index, module); |
|
|
| if let Some((parent_module, ty)) = parent_info { |
| let parent_index = |
| get_or_create_module(&mut modules, &mut module_to_index, parent_module.module); |
| let parent_module = &mut modules[parent_index]; |
| let parent_depth = parent_module.depth; |
| debug_assert!(parent_depth < u32::MAX); |
| parent_module.references.push(ModuleReference { |
| index: module_index, |
| chunking_type: ty.chunking_type.clone(), |
| export: ty.export.clone(), |
| }); |
| let module = &mut modules[module_index]; |
| module.depth = module.depth.min(parent_depth + 1); |
| module.incoming_references.push(ModuleReference { |
| index: parent_index, |
| chunking_type: ty.chunking_type.clone(), |
| export: ty.export.clone(), |
| }); |
| } else { |
| entries.push(module_index); |
| let module = &mut modules[module_index]; |
| module.depth = 0; |
| } |
|
|
| Ok(GraphTraversalAction::Continue) |
| }) |
| .await?; |
|
|
| let mut modules_by_depth = FxHashMap::default(); |
| for (index, info) in modules.iter().enumerate() { |
| modules_by_depth |
| .entry(info.depth) |
| .or_insert_with(Vec::new) |
| .push(index); |
| } |
| let mut modules_by_depth = modules_by_depth.into_iter().collect::<Vec<_>>(); |
| modules_by_depth.sort_by_key(|(depth, _)| Reverse(*depth)); |
| for (depth, module_indicies) in modules_by_depth { |
| for module_index in module_indicies { |
| let module = &modules[module_index]; |
| for ref_info in &module.incoming_references { |
| let ref_module = &modules[ref_info.index]; |
| if ref_module.depth < depth { |
| let mut retained_modules = ref_module.retained_modules.borrow_mut(); |
| retained_modules.insert(module_index as u32); |
| for retained in module.retained_modules.borrow().iter() { |
| retained_modules.insert(*retained); |
| } |
| } |
| } |
| } |
| } |
|
|
| let mut final_modules = modules |
| .iter_mut() |
| .map(async |info| { |
| Ok(ModuleInfo { |
| ident: info.module.ident().to_string().owned().await?, |
| path: info.module.ident().path().to_string().owned().await?, |
| depth: info.depth, |
| size: info |
| .module |
| .content() |
| .len() |
| .owned() |
| .await |
| |
| .unwrap_or_default() |
| .unwrap_or_default() |
| .try_into() |
| .unwrap_or(u32::MAX), |
| retained_size: 0, |
| references: take(&mut info.references), |
| incoming_references: take(&mut info.incoming_references), |
| }) |
| }) |
| .try_join() |
| .await?; |
|
|
| for (index, info) in modules.into_iter().enumerate() { |
| let retained_size = info |
| .retained_modules |
| .into_inner() |
| .iter() |
| .map(|&retained_index| { |
| let retained_info = &final_modules[retained_index as usize]; |
| retained_info.size |
| }) |
| .reduce(|a, b| a.saturating_add(b)) |
| .unwrap_or_default(); |
| final_modules[index].retained_size = retained_size + final_modules[index].size; |
| } |
|
|
| Ok(ModuleGraphSnapshot { |
| modules: final_modules, |
| entries, |
| } |
| .cell()) |
| } |
|
|
