Fix performance regressions in histogram and DNA solutions

Author: codspeed-hq[bot]

rounds/1_histogram/solution.py

@@ -4,32 +4,23 @@
 passes out of the box. Replace the body of ``compute_histogram`` with your
 own faster implementation.
 """
-from collections import defaultdict
-from mmap import mmap, ACCESS_READ
 
-def b2i(low: int, high: int) -> int:
-    return high + (low << 8)
+import numpy as np
 
-def i2b(x: int) -> bytes:
-    return bytes([(x & 0xFF00) >> 8, x & 0xFF])
 
 def compute_histogram(path: str) -> dict[bytes, int]:
     """Frequency of every 2-byte bigram in the file at ``path``."""
-    # Step 1: read the whole file into memory as a single bytes object.
-    counts = [0 for _ in range(2**16)]
-
-    source = open(path, "rb", buffering=0)
-    data = mmap(source.fileno(), 0, access=ACCESS_READ)
-
-    # Step 2: slide a 2-byte window across the buffer. For ``b"ABCD"`` the
-    # iterations produce ``b"AB"``, ``b"BC"``, then ``b"CD"``. For each window,
-    # bump the matching bucket in a ``dict`` keyed by the bigram itself.
-    previous = data[0]
-    for i in range(len(data) - 1):
-        current = data[i + 1]
-        counts[current + (previous << 8)] += 1
-        previous = current
-
-    return {
-        i2b(idx): value for idx, value in enumerate(counts) if value != 0
-    }
+    with open(path, "rb") as f:
+        data = f.read()
+
+    arr = np.frombuffer(data, dtype=np.uint8)
+
+    # Vectorised bigram index: first_byte * 256 + second_byte
+    bigram_indices = arr[:-1].astype(np.uint16) * 256 + arr[1:]
+
+    # Count every bigram in a single pass (C-level loop inside numpy)
+    counts = np.bincount(bigram_indices, minlength=65536)
+
+    # Build the result dict from non-zero entries only
+    nonzero = np.flatnonzero(counts)
+    return {int(idx).to_bytes(2, "big"): int(counts[idx]) for idx in nonzero}

rounds/3_dna/solution.py

@@ -5,58 +5,78 @@
 own faster implementation.
 """
 
-from mmap import mmap, ACCESS_READ
-from concurrent.futures import ThreadPoolExecutor, wait
+from __future__ import annotations
 
-def _subsearch(raw, record_id_start: int, data_start: int, data_end: int, pattern: bytes):
-    plen = len(pattern)
-    data = bytes(raw[data_start : data_end - 1]).replace(b"\n", b"")
-    locations = []
-    loc = data.find(pattern)
-    while loc != -1:
-        locations.append(loc)
-        loc = data.find(pattern, loc + plen)
+import os
+from concurrent.futures import ThreadPoolExecutor
 
-    if not locations:
-        return None
+_NL = 0x0A
 
-    record_id = raw[record_id_start : data_start - 1].decode("ascii")
-    return (record_id, locations)
 
 def find_matches(fasta_path: str, pattern: bytes) -> list[tuple[str, list[int]]]:
     """Find every FASTA record whose sequence contains ``pattern``.
 
     Returns ``[(record_id, [positions...]), ...]`` in file order.
     """
-    source = open(fasta_path, "rb")
-    data = mmap(source.fileno(), 0, access=ACCESS_READ)
+    with open(fasta_path, "rb") as f:
+        data = f.read()
 
-    last = -1
+    # Step 1: locate every record start ('>' at offset 0 or after '\n').
+    starts: list[int] = []
+    i = 0
+    while True:
+        p = data.find(b">", i)
+        if p == -1:
+            break
+        if p == 0 or data[p - 1] == _NL:
+            starts.append(p)
+        i = p + 1
+    starts.append(len(data))  # sentinel
 
-    data_end = len(data) - 1
-    while data[data_end] == b"\n":
-        data_end -= 1
+    num_records = len(starts) - 1
+    if num_records <= 0:
+        return []
 
-    with ThreadPoolExecutor(max_workers=16) as executor:
-        records = []
-        while data_end > 0:
-            gt_pos = data.rfind(b">", 0, data_end)
-            if gt_pos == -1:
-                raise Exception("expected greater than")
+    # Step 2: parallel scan with batched work units.
+    n_workers = max(1, os.cpu_count() or 1)
+    batches = max(1, n_workers * 4)
+    batch_size = max(1, (num_records + batches - 1) // batches)
 
-            record_id_start = gt_pos + 1
+    def scan_batch(start_idx: int, end_idx: int) -> list[tuple[int, str, list[int]]]:
+        out: list[tuple[int, str, list[int]]] = []
+        for j in range(start_idx, end_idx):
+            rec_start = starts[j]
+            rec_end = starts[j + 1]
 
-            nl_pos = data.find(b"\n", record_id_start)
-            if nl_pos == -1:
-                raise Exception("expected new line")
+            nl = data.find(b"\n", rec_start, rec_end)
+            if nl <= rec_start:
+                continue
 
-            data_start = nl_pos + 1
+            # Strip newlines so cross-line matches are found.
+            sequence = data[nl + 1 : rec_end].replace(b"\n", b"")
 
-            records.append(
-                executor.submit(_subsearch, data, record_id_start, data_start, data_end, pattern)
-            )
-            data_end = gt_pos
+            positions: list[int] = []
+            s = 0
+            while True:
+                p = sequence.find(pattern, s)
+                if p == -1:
+                    break
+                positions.append(p)
+                s = p + 1
 
-        results = [d.result() for d in records if d.result() is not None]
-        results.reverse()
-        return results
+            if positions:
+                record_id = data[rec_start + 1 : nl].decode("ascii").strip()
+                out.append((j, record_id, positions))
+        return out
+
+    with ThreadPoolExecutor(max_workers=n_workers) as pool:
+        futures = [
+            pool.submit(scan_batch, lo, min(lo + batch_size, num_records))
+            for lo in range(0, num_records, batch_size)
+        ]
+        chunks = [f.result() for f in futures]
+
+    # Step 3: flatten and restore file order.
+    flat = [item for chunk in chunks for item in chunk]
+    flat.sort(key=lambda triple: triple[0])
+    return [(rid, positions) for _, rid, positions in flat]