File size: 6,782 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 |
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,
// TODO this should be per layer
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
// TODO all modules should report some content and should not crash
.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())
}
|