let now = jiff::Timestamp::now().as_second();
        let jobs_in_last_30s_start = self.stats.jobs_in_last_30s_start.load(Ordering::Relaxed);
        let jobs_in_last_30s_count = self.stats.jobs_in_last_30s_count.load(Ordering::Relaxed);

        // ensure that we dont submit more than 4 jobs in 30s
        if now <= (jobs_in_last_30s_start + 30)
            && jobs_in_last_30s_count >= 4
            // ensure that we havent already finished some of them, because then its fine again
            && self.stats.get_current_jobs() >= 4
        {
            return false;
        } else if now > (jobs_in_last_30s_start + 30) {
            // reset count
            self.stats
                .jobs_in_last_30s_start
                .store(0, Ordering::Relaxed);
            self.stats
                .jobs_in_last_30s_count
                .store(0, Ordering::Relaxed);
        }

    #[tracing::instrument(skip(v, jobset), err)]
    pub fn new(v: db::models::Build, jobset: Arc<Jobset>) -> Result<Arc<Self>, jiff::Error> {
        Ok(Arc::new(Self {
            id: v.id,
            drv_path: v.drvpath,
            outputs: BTreeMap::new(),
            jobset_id: v.jobset_id,
            name: v.job,
            timestamp: jiff::Timestamp::from_second(v.timestamp)?,
            max_silent_time: v.maxsilent.unwrap_or(3600),
            timeout: v.timeout.unwrap_or(36000),
            local_priority: v.priority,
            global_priority: v.globalpriority.into(),
            toplevel: arc_swap::ArcSwapOption::from(None),
            jobset,
            finished_in_db: false.into(),
        }))
    }

in a competing builds scenario

There was almost no CPU pressure during the last attempt on that builder.

283: maxSilent = 14400; # 4h, double the default of 7200s; sometimes needed for x86_64-darwin on hydra