fn run()

in rd-hashd/src/hasher.rs [256:328]
60 lines of code
8 McCabe index (conditional complexity)

    fn run(self) {
        let mut rng = SmallRng::from_entropy();

        let mut file_dist = Vec::<u64>::new();
        let mut anon_dist = Vec::<u64>::new();
        file_dist.resize(self.file_dist_slots, 0);
        anon_dist.resize(self.anon_dist_slots, 0);

        let rw_uniform = Uniform::new_inclusive(0.0, 1.0);

        // Load hash input files.
        let file_addr_normal = ClampedNormal::new(0.0, self.file_addr_stdev_ratio, -1.0, 1.0);

        trace!("hasher::run(): cpu_ratio={:.2}", self.cpu_ratio);
        let mut rdh = Hasher::new(self.cpu_ratio, self.fake_cpu_load_time_per_byte);
        for _ in 0..self.file_nr_chunks {
            let rel = file_addr_normal.sample(&mut rng) * self.file_addr_frac;
            let page = self.rel_to_file_page(rel);
            let (file_idx, file_off) = self.file_page_to_idx_off(page);
            let path = self.tf.path(file_idx);
            let is_write =
                self.file_write_frac != 0.0 && rw_uniform.sample(&mut rng) <= self.file_write_frac;

            match rdh.load(&path, file_off, *PAGE_SIZE * self.chunk_pages, is_write) {
                Ok(size) => Self::file_dist_count(
                    &mut file_dist,
                    page,
                    (size / *PAGE_SIZE) as u64,
                    &self.tf,
                ),
                Err(e) => error!("Failed to load {:?}:{} ({:?})", &path, file_off, &e),
            }
        }
        sleep(Duration::from_secs_f64(self.sleep_dur / 3.0));

        // Generate anonymous accesses.
        let aa = self.anon_area.read().unwrap();
        let anon_addr_normal = ClampedNormal::new(0.0, self.anon_addr_stdev_ratio, -1.0, 1.0);

        for _ in 0..self.anon_nr_chunks {
            let rel = anon_addr_normal.sample(&mut rng) * self.anon_addr_frac;
            let page_base =
                AnonArea::rel_to_page_idx(rel, aa.size() - (self.chunk_pages - 1) * *PAGE_SIZE);
            let is_write =
                self.anon_write_frac != 0.0 && rw_uniform.sample(&mut rng) <= self.anon_write_frac;

            for page_idx in page_base..page_base + self.chunk_pages {
                let page: &mut [u64] = aa.access_page(page_idx);
                if page[0] == 0 {
                    aa.fill_page_with_random(page_idx);
                }
                if is_write {
                    page[0] = page[0].wrapping_add(1).max(1);
                }
                rdh.append(aa.access_page(page_idx))
            }
            Self::anon_dist_count(&mut anon_dist, page_base, self.chunk_pages, &aa);
        }
        sleep(Duration::from_secs_f64(self.sleep_dur / 3.0));

        // Calculate sha1 and signal completion.
        let digest = rdh.sha1();
        sleep(Duration::from_secs_f64(self.sleep_dur / 3.0));

        self.cmpl_tx
            .send(HashCompletion {
                digest,
                started_at: self.started_at,
                file_dist,
                anon_dist,
            })
            .unwrap();
    }