Add linker job limit

Status	File	+	-
M	`src/args.rs`	60	0
M	`src/lib.rs`	42	11
M	`src/main.rs`	1	0
M	`src/resolve.rs`	21	12
M	`tests/determinism.rs`	16	0
M	`tests/resolve_integration.rs`	2	2
M	`tests/snapshots/help.txt`	1	0

src/args.rsmodified

      "-dylib",
      "-all_load",
      "-force_load",
 +    "-j",
      "--dump",
      "--dump-archive",
      "--dump-dylib",
      Ok((major << 16) | ((minor & 0xff) << 8) | (patch & 0xff))
+ }
 +fn parse_jobs(value: &str) -> Result<usize, ArgsError> {
 +    let jobs = value
 +        .parse::<usize>()
 +        .map_err(|_| ArgsError::InvalidValue {
 +            flag: "-j".into(),
 +            value: value.to_string(),
 +            expected: "positive integer job count".into(),
 +        })?;
 +    if jobs == 0 {
 +        return Err(ArgsError::InvalidValue {
 +            flag: "-j".into(),
 +            value: value.to_string(),
 +            expected: "positive integer job count".into(),
 +        });
 +    }
 +    Ok(jobs)
 +}
++
  pub fn parse(argv: &[String]) -> Result<LinkOptions, ArgsError> {
      let normalized = normalize_wl(argv);
      let mut opts = LinkOptions::default();
                          ArgsError::MissingValue("-force_load".into())
                      })?));
+             }
 +            "-j" => {
 +                let value = it
 +                    .next()
 +                    .ok_or_else(|| ArgsError::MissingValue("-j".into()))?;
 +                opts.jobs = Some(parse_jobs(value)?);
 +            }
              "--dump" => {
                  opts.dump = Some(PathBuf::from(
                      it.next()
          assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
+     }
 +    #[test]
 +    fn jobs_flag_records_positive_worker_limit() {
 +        let opts = parse(&argv(&["-j", "1", "main.o"])).unwrap();
 +        assert_eq!(opts.jobs, Some(1));
 +        assert_eq!(opts.inputs, vec![PathBuf::from("main.o")]);
 +    }
++
 +    #[test]
 +    fn jobs_flag_rejects_zero_or_non_numeric_values() {
 +        let err = parse(&argv(&["-j", "0"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-j" && value == "0"
 +        ));
 +        let err = parse(&argv(&["-j", "many"])).unwrap_err();
 +        assert!(matches!(
 +            err,
 +            ArgsError::InvalidValue {
 +                ref flag,
 +                ref value,
 +                ..
 +            } if flag == "-j" && value == "many"
 +        ));
 +    }
++
 +    #[test]
 +    fn missing_jobs_value_errors() {
 +        let err = parse(&argv(&["-j"])).unwrap_err();
 +        assert!(matches!(err, ArgsError::MissingValue(ref f) if f == "-j"));
 +    }
++
      #[test]
      fn missing_force_load_value_errors() {
          let err = parse(&argv(&["-force_load"])).unwrap_err();

src/lib.rsmodified

      pub fixup_chains: bool,
      pub all_load: bool,
      pub force_load_archives: Vec<PathBuf>,
 +    pub jobs: Option<usize>,
      pub kind: OutputKind,
      /// When set, afs-ld operates in dump mode and prints the given file's
      /// header + load commands instead of linking.
              fixup_chains: false,
              all_load: false,
              force_load_archives: Vec::new(),
 +            jobs: None,
              kind: OutputKind::Executable,
              dump: None,
              dump_archive: None,
+     }
+ }
 +impl LinkOptions {
 +    pub fn parallel_jobs(&self) -> usize {
 +        self.jobs
 +            .unwrap_or_else(|| {
 +                thread::available_parallelism()
 +                    .map(usize::from)
 +                    .unwrap_or(1)
 +            })
 +            .max(1)
 +    }
 +}
++
  #[derive(Debug)]
  pub enum LinkError {
      /// No input files were provided on the command line.
          if opts.inputs.is_empty() && opts.library_names.is_empty() && opts.frameworks.is_empty() {
              return Err(LinkError::NoInputs);
+         }
 +        let parallel_jobs = opts.parallel_jobs();
          if let Some(arch) = &opts.arch {
              if arch != "arm64" {
+             }
              initial_loads.push((load_order, path.clone()));
+         }
 -        for loaded in load_initial_inputs(initial_loads)? {
 +        for loaded in load_initial_inputs(initial_loads, parallel_jobs)? {
              let timings = register_loaded_initial_input(&mut inputs, loaded);
              phases.add_input_load(timings);
+         }
          let mut force_report = DrainReport::default();
          if opts.all_load {
 -            force_load_all(&mut inputs, &mut sym_table, &mut force_report)?;
 +            force_load_all(
 +                &mut inputs,
 +                &mut sym_table,
 +                &mut force_report,
 +                parallel_jobs,
 +            )?;
+         }
          for archive_path in &opts.force_load_archives {
              let Some(archive_id) = find_archive_by_path(&inputs, archive_path) else {
                  return Err(LinkError::ForceLoadNotArchive(archive_path.clone()));
              };
 -            force_load_archive(&mut inputs, &mut sym_table, archive_id, &mut force_report)?;
 +            force_load_archive(
 +                &mut inputs,
 +                &mut sym_table,
 +                archive_id,
 +                &mut force_report,
 +                parallel_jobs,
 +            )?;
+         }
          if opts.trace_inputs {
              for path in &force_report.loaded_paths {
              return Err(LinkError::DuplicateSymbols(msg));
+         }
 -        let drain_report = drain_fetches(&mut inputs, &mut sym_table, seed_report.pending_fetches)?;
 +        let drain_report = drain_fetches(
 +            &mut inputs,
 +            &mut sym_table,
 +            seed_report.pending_fetches,
 +            parallel_jobs,
 +        )?;
          if opts.trace_inputs {
              for path in &drain_report.loaded_paths {
                  eprintln!("afs-ld: loading {}", path.display());
      error: LinkError,
+ }
 -fn load_initial_inputs(loads: Vec<(usize, PathBuf)>) -> Result<Vec<LoadedInitialInput>, LinkError> {
 +fn load_initial_inputs(
 +    loads: Vec<(usize, PathBuf)>,
 +    parallel_jobs: usize,
 +) -> Result<Vec<LoadedInitialInput>, LinkError> {
      let mut results = Vec::new();
      let mut object_jobs = Vec::new();
      for (load_order, path) in loads {
              object_jobs.push((load_order, path));
+         }
+     }
 -    results.extend(load_objects_parallel(object_jobs));
 +    results.extend(load_objects_parallel(object_jobs, parallel_jobs));
      results.sort_by_key(|result| match result {
          Ok(input) => input.load_order(),
          Err(error) => error.load_order,
  fn load_objects_parallel(
      jobs: Vec<(usize, PathBuf)>,
 +    parallel_jobs: usize,
  ) -> Vec<Result<LoadedInitialInput, InitialLoadError>> {
      if jobs.is_empty() {
          return Vec::new();
+     }
 -    let job_count = thread::available_parallelism()
 -        .map(usize::from)
 -        .unwrap_or(1)
 -        .min(jobs.len())
 -        .max(1);
 +    let job_count = parallel_jobs.max(1).min(jobs.len()).max(1);
      if job_count == 1 {
          return jobs
              .into_iter()

src/main.rsmodified

                                    Select chained fixups vs classic dyld info
    -all_load                       Force-load every archive member
    -force_load <archive>           Force-load one archive
 +  -j <jobs>                       Limit parallel worker jobs (`1` disables parallelism)
    -Wl,<arg,arg,...>               Normalize comma-separated driver flags
    --dump <path>                   Dump a Mach-O file summary
    --dump-archive <path>           Dump an archive summary

src/resolve.rsmodified

  fn load_archive_members_parallel(
      inputs: &Inputs,
      keys: Vec<ArchiveMemberKey>,
 +    parallel_jobs: usize,
  ) -> Vec<(ArchiveMemberKey, Result<LoadedArchiveMember, FetchError>)> {
      let jobs = make_archive_member_jobs(inputs, keys);
      if jobs.is_empty() {
          return Vec::new();
+     }
 -    let job_count = thread::available_parallelism()
 -        .map(usize::from)
 -        .unwrap_or(1)
 -        .min(jobs.len())
 -        .max(1);
 +    let job_count = parallel_jobs.max(1).min(jobs.len()).max(1);
      if job_count == 1 {
          return jobs
              .into_iter()
      table: &mut SymbolTable,
      key: ArchiveMemberKey,
      report: &mut DrainReport,
 +    parallel_jobs: usize,
  ) -> Result<Vec<PendingFetch>, FetchError> {
      if archive_member_is_fetched(inputs, key) {
          return Ok(Vec::new());
+     }
 -    let loaded = load_archive_members_parallel(inputs, vec![key])
 +    let loaded = load_archive_members_parallel(inputs, vec![key], parallel_jobs)
          .into_iter()
          .next()
          .expect("single archive member load should produce one result")
      table: &mut SymbolTable,
      pending: PendingFetch,
      report: &mut DrainReport,
 +    parallel_jobs: usize,
  ) -> Result<Vec<PendingFetch>, FetchError> {
      let slot_is_still_lazy = matches!(table.get(pending.id), Symbol::LazyArchive { .. });
      if !slot_is_still_lazy {
          return Ok(Vec::new());
+     }
 -    load_and_ingest_member(inputs, table, archive_member_key(pending), report)
 +    load_and_ingest_member(
 +        inputs,
 +        table,
 +        archive_member_key(pending),
 +        report,
 +        parallel_jobs,
 +    )
+ }
  /// Pull every member of one archive (bypasses demand tracking). Respects
      table: &mut SymbolTable,
      archive_id: ArchiveId,
      report: &mut DrainReport,
 +    parallel_jobs: usize,
  ) -> Result<(), FetchError> {
      let member_offsets: Vec<u32> = {
          let ai = &inputs.archives[archive_id.0 as usize];
          })
          .collect();
      let mut queue: Vec<PendingFetch> = Vec::new();
 -    for (_, loaded) in load_archive_members_parallel(inputs, keys) {
 +    for (_, loaded) in load_archive_members_parallel(inputs, keys, parallel_jobs) {
          let new = ingest_loaded_member(inputs, table, loaded?, report)?;
          queue.extend(new);
+     }
      while let Some(p) = queue.pop() {
 -        let new = fetch_and_ingest_one(inputs, table, p, report)?;
 +        let new = fetch_and_ingest_one(inputs, table, p, report, parallel_jobs)?;
          queue.extend(new);
+     }
      Ok(())
      inputs: &mut Inputs,
      table: &mut SymbolTable,
      report: &mut DrainReport,
 +    parallel_jobs: usize,
  ) -> Result<(), FetchError> {
      for i in 0..inputs.archives.len() {
 -        force_load_archive(inputs, table, ArchiveId(i as u32), report)?;
 +        force_load_archive(inputs, table, ArchiveId(i as u32), report, parallel_jobs)?;
+     }
      Ok(())
+ }
      inputs: &mut Inputs,
      table: &mut SymbolTable,
      initial: Vec<PendingFetch>,
 +    parallel_jobs: usize,
  ) -> Result<DrainReport, FetchError> {
      let mut queue = initial;
      let mut prepared = HashMap::new();
          // Parse siblings ahead of time, but only ingest the current stack
          // entry after re-checking its lazy slot. This keeps member order stable.
          if !prepared.contains_key(&key) {
 -            preparse_pending_fetches(inputs, table, p, &queue, &mut prepared);
 +            preparse_pending_fetches(inputs, table, p, &queue, &mut prepared, parallel_jobs);
+         }
          let Some(loaded) = prepared.remove(&key) else {
              continue;
      current: PendingFetch,
      queue: &[PendingFetch],
      prepared: &mut HashMap<ArchiveMemberKey, Result<LoadedArchiveMember, FetchError>>,
 +    parallel_jobs: usize,
  ) {
      let mut seen = HashSet::new();
      let mut keys = Vec::new();
+         }
          keys.push(key);
+     }
 -    for (key, result) in load_archive_members_parallel(inputs, keys) {
 +    for (key, result) in load_archive_members_parallel(inputs, keys, parallel_jobs) {
          prepared.insert(key, result);
+     }
+ }

tests/determinism.rsmodified

  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");
 +    let serial = link_once_with_jobs(&inputs, root, &format!("{label}-serial"), Some(1))
 +        .expect("single-worker deterministic link");
 +    assert_eq!(
 +        serial, baseline,
 +        "{label}: single-worker link differed from default parallel link"
 +    );
      let run_count = determinism_run_count();
      let jobs = determinism_jobs(run_count);
      let queue = Arc::new(Mutex::new((0..run_count).collect::<VecDeque<_>>()));
+ }
  fn link_once(inputs: &[PathBuf], root: &Path, run_name: &str) -> Result<Vec<u8>, String> {
 +    link_once_with_jobs(inputs, root, run_name, None)
 +}
++
 +fn link_once_with_jobs(
 +    inputs: &[PathBuf],
 +    root: &Path,
 +    run_name: &str,
 +    jobs: Option<usize>,
 +) -> Result<Vec<u8>, String> {
      let dir = root.join(run_name);
      fs::create_dir_all(&dir).map_err(|e| format!("create {}: {e}", dir.display()))?;
      let out = dir.join("deterministic.out");
          inputs: inputs.to_vec(),
          output: Some(out.clone()),
          kind: OutputKind::Executable,
 +        jobs,
          ..LinkOptions::default()
      };
      Linker::run(&opts).map_err(|e| format!("link {}: {e}", out.display()))?;

tests/resolve_integration.rsmodified

          "unexpected duplicates in seeding: {:?}",
          seed_report.duplicates
      );
 -    let drain_report =
 -        drain_fetches(&mut inputs, &mut table, seed_report.pending_fetches).expect("drain_fetches");
 +    let drain_report = drain_fetches(&mut inputs, &mut table, seed_report.pending_fetches, 1)
 +        .expect("drain_fetches");
      assert!(
          drain_report.fetched_members >= 1,
          "expected at least one archive member fetched; got {}",

tests/snapshots/help.txtmodified

                                    Select chained fixups vs classic dyld info
    -all_load                       Force-load every archive member
    -force_load <archive>           Force-load one archive
 +  -j <jobs>                       Limit parallel worker jobs (`1` disables parallelism)
    -Wl,<arg,arg,...>               Normalize comma-separated driver flags
    --dump <path>                   Dump a Mach-O file summary
    --dump-archive <path>           Dump an archive summary

fortrangoingonforty/afs-ld / `47f6d74`

7 changed files