openevolve-fixed/examples/perf_takehome/initial_program.py

"""
Performance Take-Home: Optimize build_kernel for a VLIW SIMD processor.

The goal is to minimize CPU cycles for a parallel tree traversal algorithm.
The program runs on a simulated VLIW SIMD processor with these slot limits per cycle:
  - ALU: 12 scalar operations
  - VALU: 6 vector operations (8-element SIMD vectors)
  - Load: 2 memory reads
  - Store: 2 memory writes
  - Flow: 1 control flow instruction

Key optimization strategies:
  - VLIW parallelism: pack independent ops into single cycles
  - SIMD vectorization: process 8 batch elements per vector instruction
  - Loop unrolling to reduce overhead
  - Instruction scheduling to maximize ILP
  - Use multiply_add for certain hash stages
  - Minimize load/store by reusing scratch values

The algorithm:
  For each round (16 rounds):
    For each batch element (256 elements):
      1. Load idx and val from memory
      2. Load node_val = forest[idx]
      3. val = hash(val ^ node_val)  -- 6-stage hash
      4. idx = 2*idx + (1 if val%2==0 else 2)
      5. if idx >= n_nodes: idx = 0
      6. Store idx and val back

HASH_STAGES (each stage: op1, val1, op2, op3, val3):
  ("+", 0x7ED55D16, "+", "<<", 12)
  ("^", 0xC761C23C, "^", ">>", 19)
  ("+", 0x165667B1, "+", "<<", 5)
  ("+", 0xD3A2646C, "^", "<<", 9)
  ("+", 0xFD7046C5, "+", "<<", 3)
  ("^", 0xB55A4F09, "^", ">>", 16)

Each hash stage computes:
  tmp1 = op1(val, val1)
  tmp2 = op3(val, val3)
  val = op2(tmp1, tmp2)

Available instructions:
  ALU: (op, dst, src1, src2) where op in +, -, *, /, %, ^, &, |, <<, >>, ==, !=, <, >, <=, >=
       Also: ("multiply_add", dst, a, b, c) => dst = a*b + c
  VALU: same ops but on 8-element vectors, e.g. ("+", vdst, vsrc1, vsrc2)
  Load: ("load", dst_scratch, addr_scratch) - load mem[scratch[addr]] into scratch[dst]
        ("const", dst_scratch, value) - store constant into scratch[dst]
        ("vload", vdst, addr_scratch) - load 8 contiguous words from mem[scratch[addr]]
        ("vbroadcast", vdst, scalar_scratch) - broadcast scalar to all 8 vector lanes
  Store: ("store", addr_scratch, src_scratch) - store scratch[src] to mem[scratch[addr]]
         ("vstore", addr_scratch, vsrc) - store 8 words to mem[scratch[addr]]
  Flow:  ("select", dst, cond, true_val, false_val) - conditional select
         ("vselect", vdst, vcond, vtrue, vfalse) - vector conditional select
         ("jump", target_pc) - unconditional jump
         ("cond_jump", cond_scratch, target_pc) - conditional jump
         ("pause",) - pause execution (ignored in submission)
         ("halt",) - stop execution
  Debug: ("comment", text), ("compare", addr, key) - ignored in submission

Scratch space: 1536 words total. Each alloc_scratch(name, length) reserves contiguous words.
Vector scratch: alloc_scratch(name, 8) reserves 8 contiguous words for a vector register.

IMPORTANT VLIW NOTES:
  - All effects in a cycle are applied atomically at end of cycle
  - You can read a value and write to it in the same cycle
  - Multiple engines execute in parallel within one instruction bundle
  - An instruction bundle is a dict mapping engine names to lists of slots:
    e.g. {"alu": [(...), (...)], "load": [(...), (...)], "valu": [(...), (...)]}

Baseline (naive scalar): 147,734 cycles
Best known: 1,363 cycles (108x speedup)
"""

import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), "problem_src"))

from problem import (
    Engine,
    DebugInfo,
    SLOT_LIMITS,
    VLEN,
    N_CORES,
    SCRATCH_SIZE,
    Machine,
    Tree,
    Input,
    HASH_STAGES,
    reference_kernel,
    build_mem_image,
    reference_kernel2,
)

from collections import defaultdict


# EVOLVE-BLOCK-START
class KernelBuilder:
    def __init__(self):
        self.instrs = []
        self.scratch = {}
        self.scratch_debug = {}
        self.scratch_ptr = 0
        self.const_map = {}

    def debug_info(self):
        return DebugInfo(scratch_map=self.scratch_debug)

    def build(self, slots: list[tuple[Engine, tuple]], vliw: bool = False):
        # Simple slot packing that just uses one slot per instruction bundle
        instrs = []
        for engine, slot in slots:
            instrs.append({engine: [slot]})
        return instrs

    def add(self, engine, slot):
        self.instrs.append({engine: [slot]})

    def alloc_scratch(self, name=None, length=1):
        addr = self.scratch_ptr
        if name is not None:
            self.scratch[name] = addr
            self.scratch_debug[addr] = (name, length)
        self.scratch_ptr += length
        assert self.scratch_ptr <= SCRATCH_SIZE, "Out of scratch space"
        return addr

    def scratch_const(self, val, name=None):
        if val not in self.const_map:
            addr = self.alloc_scratch(name)
            self.add("load", ("const", addr, val))
            self.const_map[val] = addr
        return self.const_map[val]

    def build_hash(self, val_hash_addr, tmp1, tmp2, round, i):
        slots = []

        for hi, (op1, val1, op2, op3, val3) in enumerate(HASH_STAGES):
            slots.append(("alu", (op1, tmp1, val_hash_addr, self.scratch_const(val1))))
            slots.append(("alu", (op3, tmp2, val_hash_addr, self.scratch_const(val3))))
            slots.append(("alu", (op2, val_hash_addr, tmp1, tmp2)))
            slots.append(("debug", ("compare", val_hash_addr, (round, i, "hash_stage", hi))))

        return slots

    def build_kernel(
        self, forest_height: int, n_nodes: int, batch_size: int, rounds: int
    ):
        """
        Like reference_kernel2 but building actual instructions.
        Scalar implementation using only scalar ALU and load/store.
        """
        tmp1 = self.alloc_scratch("tmp1")
        tmp2 = self.alloc_scratch("tmp2")
        tmp3 = self.alloc_scratch("tmp3")
        # Scratch space addresses
        init_vars = [
            "rounds",
            "n_nodes",
            "batch_size",
            "forest_height",
            "forest_values_p",
            "inp_indices_p",
            "inp_values_p",
        ]
        for v in init_vars:
            self.alloc_scratch(v, 1)
        for i, v in enumerate(init_vars):
            self.add("load", ("const", tmp1, i))
            self.add("load", ("load", self.scratch[v], tmp1))

        zero_const = self.scratch_const(0)
        one_const = self.scratch_const(1)
        two_const = self.scratch_const(2)

        self.add("flow", ("pause",))
        self.add("debug", ("comment", "Starting loop"))

        body = []  # array of slots

        # Scalar scratch registers
        tmp_idx = self.alloc_scratch("tmp_idx")
        tmp_val = self.alloc_scratch("tmp_val")
        tmp_node_val = self.alloc_scratch("tmp_node_val")
        tmp_addr = self.alloc_scratch("tmp_addr")

        for round in range(rounds):
            for i in range(batch_size):
                i_const = self.scratch_const(i)
                # idx = mem[inp_indices_p + i]
                body.append(("alu", ("+", tmp_addr, self.scratch["inp_indices_p"], i_const)))
                body.append(("load", ("load", tmp_idx, tmp_addr)))
                body.append(("debug", ("compare", tmp_idx, (round, i, "idx"))))
                # val = mem[inp_values_p + i]
                body.append(("alu", ("+", tmp_addr, self.scratch["inp_values_p"], i_const)))
                body.append(("load", ("load", tmp_val, tmp_addr)))
                body.append(("debug", ("compare", tmp_val, (round, i, "val"))))
                # node_val = mem[forest_values_p + idx]
                body.append(("alu", ("+", tmp_addr, self.scratch["forest_values_p"], tmp_idx)))
                body.append(("load", ("load", tmp_node_val, tmp_addr)))
                body.append(("debug", ("compare", tmp_node_val, (round, i, "node_val"))))
                # val = myhash(val ^ node_val)
                body.append(("alu", ("^", tmp_val, tmp_val, tmp_node_val)))
                body.extend(self.build_hash(tmp_val, tmp1, tmp2, round, i))
                body.append(("debug", ("compare", tmp_val, (round, i, "hashed_val"))))
                # idx = 2*idx + (1 if val % 2 == 0 else 2)
                body.append(("alu", ("%", tmp1, tmp_val, two_const)))
                body.append(("alu", ("==", tmp1, tmp1, zero_const)))
                body.append(("flow", ("select", tmp3, tmp1, one_const, two_const)))
                body.append(("alu", ("*", tmp_idx, tmp_idx, two_const)))
                body.append(("alu", ("+", tmp_idx, tmp_idx, tmp3)))
                body.append(("debug", ("compare", tmp_idx, (round, i, "next_idx"))))
                # idx = 0 if idx >= n_nodes else idx
                body.append(("alu", ("<", tmp1, tmp_idx, self.scratch["n_nodes"])))
                body.append(("flow", ("select", tmp_idx, tmp1, tmp_idx, zero_const)))
                body.append(("debug", ("compare", tmp_idx, (round, i, "wrapped_idx"))))
                # mem[inp_indices_p + i] = idx
                body.append(("alu", ("+", tmp_addr, self.scratch["inp_indices_p"], i_const)))
                body.append(("store", ("store", tmp_addr, tmp_idx)))
                # mem[inp_values_p + i] = val
                body.append(("alu", ("+", tmp_addr, self.scratch["inp_values_p"], i_const)))
                body.append(("store", ("store", tmp_addr, tmp_val)))

        body_instrs = self.build(body)
        self.instrs.extend(body_instrs)
        # Required to match with the yield in reference_kernel2
        self.instrs.append({"flow": [("pause",)]})
# EVOLVE-BLOCK-END