Unrolled build for rust-lang#119756

Rollup merge of rust-lang#119756 - notriddle:notriddle/reuse-map, r=GuillaumeGomez rustdoc-search: reuse individual types in function signatures Because `search.js` never mutates the function signature after loading it, they can be safely and easily reused across functions. This change doesn't change the format of the search index. It only changes `search.js`. Profiler output: https://notriddle.com/rustdoc-html-demo-9/fn-signature-opti2/index.html <table><tr><th>benchmark<th>before<th>after <tr><th>arti<td> ``` user: 002.228 s sys: 000.315 s wall: 001.663 s child_RSS_high: 315668 KiB group_mem_high: 288638 KiB ``` <td> ``` user: 001.805 s sys: 000.231 s wall: 001.398 s child_RSS_high: 235864 KiB group_mem_high: 203056 KiB ``` <tr><th>cortex-m<td> ``` user: 000.143 s sys: 000.035 s wall: 000.140 s child_RSS_high: 59168 KiB group_mem_high: 23000 KiB ``` <td> ``` user: 000.138 s sys: 000.031 s wall: 000.133 s child_RSS_high: 58944 KiB group_mem_high: 22220 KiB ``` <tr><th>sqlx<td> ``` user: 000.792 s sys: 000.115 s wall: 000.536 s child_RSS_high: 156716 KiB group_mem_high: 122948 KiB ``` <td> ``` user: 000.824 s sys: 000.084 s wall: 000.535 s child_RSS_high: 136668 KiB group_mem_high: 101792 KiB ``` <tr><th>stm32f4<td> ``` user: 006.665 s sys: 003.533 s wall: 008.624 s child_RSS_high: 1037660 KiB group_mem_high: 1022516 KiB ``` <td> ``` user: 005.997 s sys: 003.185 s wall: 007.987 s child_RSS_high: 832068 KiB group_mem_high: 810908 KiB ``` <tr><th>stm32f4xx-hal<td> ``` user: 000.317 s sys: 000.051 s wall: 000.203 s child_RSS_high: 77060 KiB group_mem_high: 41776 KiB ``` <td> ``` user: 000.287 s sys: 000.046 s wall: 000.180 s child_RSS_high: 75216 KiB group_mem_high: 39200 KiB ``` <tr><th>ripgrep<td> ``` user: 000.463 s sys: 000.063 s wall: 000.295 s child_RSS_high: 101288 KiB group_mem_high: 66364 KiB ``` <td> ``` user: 000.472 s sys: 000.036 s wall: 000.247 s child_RSS_high: 82708 KiB group_mem_high: 47056 KiB ``` </tr></table>
rust-lang-ci · Jan 9, 2024 · 64a5b69 · 64a5b69
2 parents be00c5a c3cd657
commit 64a5b69
Showing 1 changed file with 91 additions and 20 deletions.
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
@@ -2717,9 2717,33 @@ ${item.displayPath}<span class="${type}">${name}</span>\
  * @return {Array<FunctionSearchType>}
  */
  function buildItemSearchTypeAll(types, lowercasePaths) {
- return types.map(type => buildItemSearchType(type, lowercasePaths));
  return types.length > 0 ?
  types.map(type => buildItemSearchType(type, lowercasePaths)) :
  EMPTY_GENERICS_ARRAY;
  }
 
  /**
  * Empty, immutable map used in item search types with no bindings.
  *
  * @type {Map<number, Array<FunctionType>>}
  */
  const EMPTY_BINDINGS_MAP = new Map();
 
  /**
  * Empty, immutable map used in item search types with no bindings.
  *
  * @type {Array<FunctionType>}
  */
  const EMPTY_GENERICS_ARRAY = [];
 
  /**
  * Object pool for function types with no bindings or generics.
  * This is reset after loading the index.
  *
  * @type {Map<number|null, FunctionType>}
  */
  let TYPES_POOL = new Map();
 
  /**
  * Converts a single type.
  *
@@ -2732,15 2756,15 @@ ${item.displayPath}<span class="${type}">${name}</span>\
  let pathIndex, generics, bindings;
  if (typeof type === "number") {
  pathIndex = type;
- generics = [];
- bindings = new Map();
  generics = EMPTY_GENERICS_ARRAY;
  bindings = EMPTY_BINDINGS_MAP;
  } else {
  pathIndex = type[PATH_INDEX_DATA];
  generics = buildItemSearchTypeAll(
  type[GENERICS_DATA],
  lowercasePaths
  );
- if (type.length > BINDINGS_DATA) {
  if (type.length > BINDINGS_DATA && type[BINDINGS_DATA].length > 0) {
  bindings = new Map(type[BINDINGS_DATA].map(binding => {
  const [assocType, constraints] = binding;
  // Associated type constructors are represented sloppily in rustdoc's
@@ -2759,38 2783,83 @@ ${item.displayPath}<span class="${type}">${name}</span>\
  ];
  }));
  } else {
- bindings = new Map();
  bindings = EMPTY_BINDINGS_MAP;
  }
  }
  /**
  * @type {FunctionType}
  */
  let result;
  if (pathIndex < 0) {
  // types less than 0 are generic parameters
  // the actual names of generic parameters aren't stored, since they aren't API
- return {
  result = {
  id: pathIndex,
  ty: TY_GENERIC,
  path: null,
  generics,
  bindings,
  };
- }
- if (pathIndex === 0) {
  } else if (pathIndex === 0) {
  // `0` is used as a sentinel because it's fewer bytes than `null`
- return {
  result = {
  id: null,
  ty: null,
  path: null,
  generics,
  bindings,
  };
  } else {
  const item = lowercasePaths[pathIndex - 1];
  result = {
  id: buildTypeMapIndex(item.name, isAssocType),
  ty: item.ty,
  path: item.path,
  generics,
  bindings,
  };
  }
- const item = lowercasePaths[pathIndex - 1];
- return {
- id: buildTypeMapIndex(item.name, isAssocType),
- ty: item.ty,
- path: item.path,
- generics,
- bindings,
- };
  const cr = TYPES_POOL.get(result.id);
  if (cr) {
  // Shallow equality check. Since this function is used
  // to construct every type object, this should be mostly
  // equivalent to a deep equality check, except if there's
  // a conflict, we don't keep the old one around, so it's
  // not a fully precise implementation of hashcons.
  if (cr.generics.length === result.generics.length &&
  cr.generics !== result.generics &&
  cr.generics.every((x, i) => result.generics[i] === x)
  ) {
  result.generics = cr.generics;
  }
  if (cr.bindings.size === result.bindings.size && cr.bindings !== result.bindings) {
  let ok = true;
  for (const [k, v] of cr.bindings.entries()) {
  const v2 = result.bindings.get(v);
  if (!v2) {
  ok = false;
  break;
  }
  if (v !== v2 && v.length === v2.length && v.every((x, i) => v2[i] === x)) {
  result.bindings.set(k, v);
  } else if (v !== v2) {
  ok = false;
  break;
  }
  }
  if (ok) {
  result.bindings = cr.bindings;
  }
  }
  if (cr.ty === result.ty && cr.path === result.path
  && cr.bindings === result.bindings && cr.generics === result.generics
  && cr.ty === result.ty
  ) {
  return cr;
  }
  }
  TYPES_POOL.set(result.id, result);
  return result;
  }
 
  /**
@@ -2801,7 2870,7 @@ ${item.displayPath}<span class="${type}">${name}</span>\
  * object-based encoding so that the actual search code is more readable and easier to debug.
  *
  * The raw function search type format is generated using serde in
- * librustdoc/html/render/mod.rs: impl Serialize for IndexItemFunctionType
  * librustdoc/html/render/mod.rs: IndexItemFunctionType::write_to_string
  *
  * @param {{
  * string: string,
@@ -2970,8 3039,8 @@ ${item.displayPath}<span class="${type}">${name}</span>\
  const fb = {
  id: null,
  ty: 0,
- generics: [],
- bindings: new Map(),
  generics: EMPTY_GENERICS_ARRAY,
  bindings: EMPTY_BINDINGS_MAP,
  };
  for (const [k, v] of type.bindings.entries()) {
  fb.id = k;
@@ -3199,6 3268,8 @@ ${item.displayPath}<span class="${type}">${name}</span>\
  }
  currentIndex  = itemTypes.length;
  }
  // Drop the (rather large) hash table used for reusing function items
  TYPES_POOL = new Map();
  }
 
  /**