`bb7169d`

Parallelize atom relocation patching

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: bb7169d27fdb113e1806783e17df550269f4b1de
Parents: 47f6d74
Tree: 540fd13

4 changed files

Status	File	+	-
M	`src/lib.rs`	1	0
M	`src/reloc/arm64.rs`	90	36
M	`src/resolve.rs`	4	5
M	`tests/determinism.rs`	69	0

src/lib.rsmodified

                  linkedit: &linkedit,
                  icf_redirects,
                  parsed_relocs: &parsed_relocs,
 +                parallel_jobs,
              },
          )?;
          phases.reloc_apply = phase_started.elapsed();

src/reloc/arm64.rsmodified

  use std::collections::HashMap;
  use std::fmt;
  use std::path::PathBuf;
 +use std::thread;
  use crate::atom::{Atom, AtomSection, AtomTable};
  use crate::input::ObjectFile;
  use crate::macho::writer::LinkEditPlan;
  use crate::reloc::{ParsedRelocCache, Referent, Reloc, RelocKind, RelocLength};
  use crate::resolve::{InputId, Symbol, SymbolId, SymbolTable};
 -use crate::section::{OutputSection, SectionKind};
 +use crate::section::{OutputAtom, OutputSection, SectionKind};
  use crate::symbol::{InputSymbol, SymKind};
  use crate::synth::stubs::{STUB_HELPER_ENTRY_SIZE, STUB_HELPER_HEADER_SIZE, STUB_SIZE};
  use crate::synth::tlv::THREAD_VARIABLE_DESCRIPTOR_SIZE;
      pub linkedit: &'a LinkEditPlan,
      pub icf_redirects: Option<&'a HashMap<crate::resolve::AtomId, crate::resolve::AtomId>>,
      pub parsed_relocs: &'a ParsedRelocCache,
 +    pub parallel_jobs: usize,
+ }
  struct InputSectionResolveCtx<'a> {
      referent: &'a str,
+ }
 +struct RegularRelocContext<'a> {
 +    input_map: &'a HashMap<InputId, &'a ObjectFile>,
 +    atoms: &'a AtomTable,
 +    resolve: &'a ResolveView<'a>,
 +    thunk_plan: Option<&'a ThunkPlan>,
 +    thunk_addrs: Option<&'a HashMap<usize, u64>>,
 +    parsed_relocs: &'a ParsedRelocCache,
 +}
++
  const THUNK_SIZE: u64 = 12;
  const BR_X16: u32 = 0xd61f_0200;
  const BRANCH26_MAX_FORWARD_DELTA_BYTES: u64 = ((1u64 << 25) - 1) * 4;
          .thunk_plan
          .map(|thunk_plan| thunk_plan.thunk_addrs(layout));
 -    for out_section in &mut layout.sections {
 -        for placed in &mut out_section.atoms {
 -            let atom = atoms.get(placed.atom);
 -            if atom.size == 0 || placed.data.is_empty() {
 -                continue;
 -            }
 -            let obj = input_map.get(&atom.origin).ok_or_else(|| {
 -                reloc_error(
 -                    atom,
 -                    &PathBuf::from("<missing object>"),
 -                    0,
 -                    RelocKind::Unsigned,
 -                    "object",
 -                    "missing parsed object".to_string(),
 -                )
 -            })?;
 -            patch_eh_frame_cie_pointer(&mut placed.data, atom, &resolve)?;
 -            let relocs = plan
 -                .parsed_relocs
 -                .get(&(atom.origin, atom.input_section))
 -                .map(Vec::as_slice)
 -                .unwrap_or(&[]);
 -            for reloc in relocs_for_atom(relocs, atom) {
 -                apply_one(
 -                    &mut placed.data,
 -                    atom,
 -                    obj,
 -                    reloc,
 -                    &resolve,
 -                    plan.thunk_plan,
 -                    thunk_addrs.as_ref(),
 -                )?;
 -            }
 -        }
 -    }
 +    let regular_ctx = RegularRelocContext {
 +        input_map: &input_map,
 +        atoms,
 +        resolve: &resolve,
 +        thunk_plan: plan.thunk_plan,
 +        thunk_addrs: thunk_addrs.as_ref(),
 +        parsed_relocs: plan.parsed_relocs,
 +    };
 +    apply_regular_relocs(layout, &regular_ctx, plan.parallel_jobs)?;
      if let Some(thunk_plan) = plan.thunk_plan {
          synthesize_thunk_section(layout, thunk_plan, &resolve)?;
      Ok(())
+ }
 +fn apply_regular_relocs(
 +    layout: &mut Layout,
 +    ctx: &RegularRelocContext<'_>,
 +    parallel_jobs: usize,
 +) -> Result<(), RelocError> {
 +    let parallel_jobs = parallel_jobs.max(1);
 +    for out_section in &mut layout.sections {
 +        let atom_count = out_section.atoms.len();
 +        if parallel_jobs == 1 || atom_count < 2 {
 +            apply_regular_atom_chunk(&mut out_section.atoms, ctx)?;
 +            continue;
 +        }
++
 +        let job_count = parallel_jobs.min(atom_count).max(1);
 +        let chunk_size = atom_count.div_ceil(job_count);
 +        thread::scope(|scope| {
 +            let mut handles = Vec::new();
 +            for chunk in out_section.atoms.chunks_mut(chunk_size) {
 +                handles.push(scope.spawn(move || apply_regular_atom_chunk(chunk, ctx)));
 +            }
 +            for handle in handles {
 +                handle.join().expect("relocation worker panicked")?;
 +            }
 +            Ok::<(), RelocError>(())
 +        })?;
 +    }
 +    Ok(())
 +}
++
 +fn apply_regular_atom_chunk(
 +    placed_atoms: &mut [OutputAtom],
 +    ctx: &RegularRelocContext<'_>,
 +) -> Result<(), RelocError> {
 +    for placed in placed_atoms {
 +        let atom = ctx.atoms.get(placed.atom);
 +        if atom.size == 0 || placed.data.is_empty() {
 +            continue;
 +        }
 +        let obj = ctx.input_map.get(&atom.origin).ok_or_else(|| {
 +            reloc_error(
 +                atom,
 +                &PathBuf::from("<missing object>"),
 +                0,
 +                RelocKind::Unsigned,
 +                "object",
 +                "missing parsed object".to_string(),
 +            )
 +        })?;
 +        patch_eh_frame_cie_pointer(&mut placed.data, atom, ctx.resolve)?;
 +        let relocs = ctx
 +            .parsed_relocs
 +            .get(&(atom.origin, atom.input_section))
 +            .map(Vec::as_slice)
 +            .unwrap_or(&[]);
 +        for reloc in relocs_for_atom(relocs, atom) {
 +            apply_one(
 +                &mut placed.data,
 +                atom,
 +                obj,
 +                reloc,
 +                ctx.resolve,
 +                ctx.thunk_plan,
 +                ctx.thunk_addrs,
 +            )?;
 +        }
 +    }
 +    Ok(())
 +}
++
  fn patch_eh_frame_cie_pointer(
      bytes: &mut [u8],
      atom: &Atom,

src/resolve.rsmodified

  use std::collections::{HashMap, HashSet, VecDeque};
  use std::path::{Path, PathBuf};
 -use std::rc::Rc;
  use std::sync::{mpsc, Arc, Mutex};
  use std::thread;
  #[derive(Debug, Default)]
  pub struct StringInterner {
 -    strings: Vec<Rc<str>>,
 -    index: HashMap<Rc<str>, u32>,
 +    strings: Vec<Arc<str>>,
 +    index: HashMap<Arc<str>, u32>,
+ }
  impl StringInterner {
+     }
      /// Intern `s`, returning the existing handle when the string was already
 -    /// seen. Allocates at most one `Rc<str>` per unique name.
 +    /// seen. Allocates at most one `Arc<str>` per unique name.
      pub fn intern(&mut self, s: &str) -> Istr {
          if let Some(&i) = self.index.get(s) {
              return Istr(i);
+         }
 -        let rc: Rc<str> = Rc::from(s);
 +        let rc: Arc<str> = Arc::from(s);
          let id = self.strings.len() as u32;
          self.strings.push(rc.clone());
          self.index.insert(rc, id);

tests/determinism.rsmodified

      let _ = fs::remove_dir_all(root);
+ }
 +#[test]
 +fn relocation_workers_match_single_worker_for_many_atoms() {
 +    if !have_xcrun() || !have_xcrun_tool("as") {
 +        eprintln!("skipping: xcrun as unavailable");
 +        return;
 +    }
++
 +    let root = unique_temp_dir("reloc-workers").expect("create relocation worker temp dir");
 +    let text_obj = root.join("text.o");
 +    let data_obj = root.join("data.o");
++
 +    let mut asm = String::from(
 +        "\
 +        .section __TEXT,__text,regular,pure_instructions\n\
 +        .globl _main\n\
 +        _main:\n",
 +    );
 +    for index in 0..64 {
 +        asm.push_str(&format!("            bl _helper_{index}\n"));
 +    }
 +    asm.push_str(
 +        "\
 +            adrp x8, _value@GOTPAGE\n\
 +            ldr x8, [x8, _value@GOTPAGEOFF]\n\
 +            ldr w0, [x8]\n\
 +            ret\n\
 +\n",
 +    );
 +    for index in 0..64 {
 +        asm.push_str(&format!(
 +            "\
 +        .globl _helper_{index}\n\
 +        _helper_{index}:\n\
 +            adrp x9, _value@GOTPAGE\n\
 +            ldr x9, [x9, _value@GOTPAGEOFF]\n\
 +            ldr w9, [x9]\n\
 +            ret\n\
 +\n"
 +        ));
 +    }
 +    asm.push_str("        .subsections_via_symbols\n");
++
 +    assemble(&asm, &text_obj).expect("assemble relocation worker text fixture");
 +    assemble(
 +        "\
 +        .section __DATA,__data\n\
 +        .globl _value\n\
 +        .p2align 2\n\
 +        _value:\n\
 +            .long 11\n\
 +\n\
 +        .subsections_via_symbols\n",
 +        &data_obj,
 +    )
 +    .expect("assemble relocation worker data fixture");
++
 +    let inputs = vec![text_obj, data_obj];
 +    let serial =
 +        link_once_with_jobs(&inputs, &root, "reloc-workers-serial", Some(1)).expect("serial link");
 +    let parallel = link_once_with_jobs(&inputs, &root, "reloc-workers-parallel", Some(8))
 +        .expect("parallel link");
 +    assert_eq!(
 +        parallel, serial,
 +        "parallel relocation workers changed final output bytes"
 +    );
++
 +    let _ = fs::remove_dir_all(root);
 +}
++
  fn assert_repeated_links_identical(inputs: Vec<PathBuf>, root: &Path, label: &str) {
      let baseline = link_once(&inputs, root, &format!("{label}-baseline"))
          .expect("baseline deterministic link");