Speed up Acton benchmark loops

bench/algorithm/knucleotide/1.act

@@ -3,14 +3,38 @@
 
 import file
 
-def frequencies(sequence: bytes, k: int) -> dict[int, int]:
-    counts: dict[int, int] = {}
+# Keep the count unboxed; updating an int in a list/dict allocates today.
+# TODO: Drop this workaround when Acton can update those ints unboxed.
+class StupidBox(object):
+    value: int
+
+    def __init__(self, value: int):
+        self.value = value
+
+def frequencies(sequence: bytes, k: int) -> dict[int, StupidBox]:
+    if k <= 6:
+        # Short keys fit in at most 4096 slots, so avoid hashing each base.
+        # TODO: Recheck this extra path once Acton's integer hashing stops
+        # allocating temporary objects.
+        counters = [StupidBox(0) for _ in range(1 << (2 * k))]
+        mask = (1 << (2 * k)) - 1
+        key = 0
+        for i in range(len(sequence)):
+            key = ((key << 2) | ((sequence[i] >> 1) & 3)) & mask
+            if i >= k - 1:
+                counters[key].value += 1
+        return {key: counter for key, counter in enumerate(counters) if counter.value != 0}
+    counts: dict[int, StupidBox] = {}
     mask = (1 << (2 * k)) - 1
     key = 0
     for i in range(len(sequence)):
         key = ((key << 2) | ((sequence[i] >> 1) & 3)) & mask
         if i >= k - 1:
-            counts[key] = counts[key] + 1 if key in counts else 1
+            counter = counts.get(key)
+            if counter is not None:
+                counter.value += 1
+            else:
+                counts[key] = StupidBox(1)
     return counts
 
 def compress(text: str) -> int:
@@ -43,12 +67,12 @@ actor main(env):
     sequence = b"".join(parts)
     for k in [1, 2]:
         counts = frequencies(sequence, k)
-        rows = [(-count, decompress(key, k)) for key, count in counts.items()]
+        rows = [(-count.value, decompress(key, k)) for key, count in counts.items()]
         for negative_count, text in sorted(rows):
             print("%s %.3f" % (text, -100.0 * float(negative_count) / float(len(sequence) - k + 1)))
         print("")
     for text in ["GGT", "GGTA", "GGTATT", "GGTATTTTAATT", "GGTATTTTAATTTATAGT"]:
         counts = frequencies(sequence, len(text))
         key = compress(text)
-        print("%d\t%s" % (counts[key] if key in counts else 0, text))
+        print("%d\t%s" % (counts[key].value if key in counts else 0, text))
     env.exit(0)

bench/algorithm/nsieve/1.act

@@ -1,13 +1,19 @@
 #!/usr/bin/env runacton
 
 def nsieve(n: int):
-    count = 0
-    flags = [True] * n
-    for i in range(2, n, 1):
-        if flags[i]:
-            count += 1
-            for j in range(i, n, i):
-                flags[j] = False
+    flags = bytearray(b"\x01" * n)
+    if n > 0:
+        flags[0] = 0
+    if n > 1:
+        flags[1] = 0
+    i = 2
+    while i * i < n:
+        if flags[i] != 0:
+            start = i * i
+            # TODO: Retry a plain loop once bytearray stores avoid boxing.
+            flags[start:n:i] = b"\x00" * ((n - 1 - start) // i + 1)
+        i += 1
+    count = flags.count(bytearray(b"\x01"))
     n_s = ""
     for j in range(0, (8-(len(str(n)))), 1):
         n_s += " "

bench/algorithm/spectral-norm/1.act

@@ -7,11 +7,15 @@ def multiply(u: list[float], v: list[float], transpose: bool):
     n = len(u)
     for i in range(n):
         total = 0.0
-        # Advancing the denominator avoids an integer multiply per element.
-        denominator = i * (i + 1) // 2 + (1 if transpose else i + 1)
+        # Integer-valued floats stay exact at the benchmark sizes.
+        # TODO: Return to integer arithmetic once float(int) avoids boxing:
+        # https://github.com/actonlang/acton/issues/3148
+        denominator = float(i * (i + 1) // 2 + (1 if transpose else i + 1))
+        step = float(i + (2 if transpose else 1))
         for j in range(n):
-            total += u[j] / float(denominator)
-            denominator += i + j + (2 if transpose else 1)
+            total += u[j] / denominator
+            denominator += step
+            step += 1.0
         v[i] = total
 
 def multiply_ata(u: list[float], v: list[float], scratch: list[float]):