Speed string table planning

Status	File	+	-
M	`src/lib.rs`	12	0
M	`src/string_table.rs`	42	9
M	`tests/perf_baseline.rs`	11	1

src/lib.rsmodified

      pub synth_sections: Duration,
      pub synth_linkedit_finalize: Duration,
      pub synth_linkedit_symbol_plan: Duration,
++    pub synth_linkedit_symbol_plan_locals: Duration,
++    pub synth_linkedit_symbol_plan_globals: Duration,
++    pub synth_linkedit_symbol_plan_strtab: Duration,
      pub synth_linkedit_dyld_info: Duration,
      pub synth_linkedit_metadata_tables: Duration,
      pub synth_linkedit_code_signature: Duration,
          let mut linkedit = None;
          let mut synth_linkedit_finalize = Duration::ZERO;
          let mut synth_linkedit_symbol_plan = Duration::ZERO;
++        let mut synth_linkedit_symbol_plan_locals = Duration::ZERO;
++        let mut synth_linkedit_symbol_plan_globals = Duration::ZERO;
++        let mut synth_linkedit_symbol_plan_strtab = Duration::ZERO;
          let mut synth_linkedit_dyld_info = Duration::ZERO;
          let mut synth_linkedit_metadata_tables = Duration::ZERO;
          let mut synth_linkedit_code_signature = Duration::ZERO;
                  )?;
              synth_linkedit_finalize += phase_started.elapsed();
              synth_linkedit_symbol_plan += linkedit_timings.symbol_plan;
++            synth_linkedit_symbol_plan_locals += linkedit_timings.symbol_plan_locals;
++            synth_linkedit_symbol_plan_globals += linkedit_timings.symbol_plan_globals;
++            synth_linkedit_symbol_plan_strtab += linkedit_timings.symbol_plan_strtab;
              synth_linkedit_dyld_info += linkedit_timings.dyld_info;
              synth_linkedit_metadata_tables += linkedit_timings.metadata_tables;
              synth_linkedit_code_signature += linkedit_timings.code_signature;
          let linkedit = linkedit.expect("finalize loop always runs at least once");
          phases.synth_linkedit_finalize = synth_linkedit_finalize;
          phases.synth_linkedit_symbol_plan = synth_linkedit_symbol_plan;
++        phases.synth_linkedit_symbol_plan_locals = synth_linkedit_symbol_plan_locals;
++        phases.synth_linkedit_symbol_plan_globals = synth_linkedit_symbol_plan_globals;
++        phases.synth_linkedit_symbol_plan_strtab = synth_linkedit_symbol_plan_strtab;
          phases.synth_linkedit_dyld_info = synth_linkedit_dyld_info;
          phases.synth_linkedit_metadata_tables = synth_linkedit_metadata_tables;
          phases.synth_linkedit_code_signature = synth_linkedit_code_signature;

src/string_table.rsmodified

  #[derive(Debug, Clone, Default, PartialEq, Eq)]
  pub struct StringTableBuilder {
--    roots: Vec<(String, u32)>,
++    roots: Vec<RootString>,
++    roots_by_last_byte: HashMap<u8, Vec<usize>>,
      offsets: HashMap<String, u32>,
+ }
++#[derive(Debug, Clone, PartialEq, Eq)]
++struct RootString {
++    name: String,
++    offset: u32,
++}
++
  impl StringTableBuilder {
      pub fn new() -> Self {
          Self::default()
              let offset = raw.len() as u32;
              raw.extend_from_slice(name.as_bytes());
              raw.push(0);
--            self.roots.push((name.clone(), offset));
++            let root_index = self.roots.len();
++            self.roots.push(RootString {
++                name: name.clone(),
++                offset,
++            });
++            if let Some(&last_byte) = name.as_bytes().last() {
++                self.roots_by_last_byte
++                    .entry(last_byte)
++                    .or_default()
++                    .push(root_index);
++            }
              self.offsets.insert(name, offset);
+         }
+     }
      fn find_suffix_offset(&self, name: &str) -> Option<u32> {
--        self.roots.iter().find_map(|(existing, offset)| {
++        let last_byte = *name.as_bytes().last()?;
--            if existing.ends_with(name) {
++        self.roots_by_last_byte
--                Some(*offset + (existing.len() - name.len()) as u32)
++            .get(&last_byte)?
--            } else {
++            .iter()
--                None
++            .find_map(|&idx| {
--            }
++                let existing = &self.roots[idx];
--        })
++                (existing.name.len() >= name.len() && existing.name.ends_with(name)).then(|| {
++                    existing.offset + (existing.name.len() - name.len()) as u32
++                })
++            })
+     }
+ }
          assert_eq!(array, afs + 4);
          assert_eq!(table.as_bytes().len() % 8, 0);
+     }
++
++    #[test]
++    fn builder_ignores_same_last_byte_non_suffix_names() {
++        let mut builder = StringTableBuilder::new();
++        builder.insert("_alpha");
++        builder.insert("_beta");
++
++        let (bytes, offsets) = builder.finish();
++        let table = StringTable::from_bytes(bytes);
++
++        assert_eq!(table.get(offsets["_alpha"]).unwrap(), "_alpha");
++        assert_eq!(table.get(offsets["_beta"]).unwrap(), "_beta");
++    }
+ }

tests/perf_baseline.rsmodified

  fn assert_profile_basics(name: &str, profile: &LinkProfile) {
      eprintln!(
--        "{name}: total={:?} parse={:?} resolve={:?} atomize={:?} layout={:?} synth={:?} (linkedit={:?}: symbols={:?} dyld={:?} metadata={:?} codesig={:?}; unwind={:?}) reloc={:?} write={:?}",
++        "{name}: total={:?} parse={:?} resolve={:?} atomize={:?} layout={:?} synth={:?} (linkedit={:?}: symbols={:?} [locals={:?} globals={:?} strtab={:?}] dyld={:?} metadata={:?} codesig={:?}; unwind={:?}) reloc={:?} write={:?}",
          profile.total_wall,
          profile.phases.input_parsing,
          profile.phases.symbol_resolution,
          profile.phases.synth_sections,
          profile.phases.synth_linkedit_finalize,
          profile.phases.synth_linkedit_symbol_plan,
++        profile.phases.synth_linkedit_symbol_plan_locals,
++        profile.phases.synth_linkedit_symbol_plan_globals,
++        profile.phases.synth_linkedit_symbol_plan_strtab,
          profile.phases.synth_linkedit_dyld_info,
          profile.phases.synth_linkedit_metadata_tables,
          profile.phases.synth_linkedit_code_signature,
                  + profile.phases.synth_linkedit_code_signature,
          "{name}: linkedit subphases exceeded linkedit total"
      );
++    assert!(
++        profile.phases.synth_linkedit_symbol_plan
++            >= profile.phases.synth_linkedit_symbol_plan_locals
++                + profile.phases.synth_linkedit_symbol_plan_globals
++                + profile.phases.synth_linkedit_symbol_plan_strtab,
++        "{name}: symbol-plan subphases exceeded symbol-plan total"
++    );
  }
  #[test]

fortrangoingonforty/afs-ld / `86f5fa3`

3 changed files