tiny.simd.AutoTune

1pub fn AutoTune(2    comptime Config: type,3    comptime max_candidates: usize,4    comptime min_samples: usize,5) type {6    comptime {7        if (min_samples < 2) @compileError("AutoTune requires at least two samples");8    }9    const CandidateList = NextWithSkip(max_candidates);1011    return struct {12        best_index: ?usize = null,13        candidate_values: [max_candidates]Config = undefined,14        cost_values: [max_candidates]CostDistribution = @splat(.{}),15        candidate_count: usize = 0,16        config_index: usize = 0,17        list: CandidateList = .{},18        rounds_complete: usize = 0,19        skip_if_above: f64 = 0,2021        const Self = @This();22        pub const SetCandidatesError = error{23            NoCandidates,24            TooManyCandidates,25            AlreadyConfigured,26        };2728        pub fn best(self: *const Self) ?*const Config {29            const index = self.best_index orelse return null;30            return &self.candidate_values[index];31        }3233        pub fn hasCandidates(self: *const Self) bool {34            return self.candidate_count != 0;35        }3637        pub fn setCandidates(38            self: *Self,39            candidates_to_copy: []const Config,40        ) SetCandidatesError!void {41            if (self.hasCandidates()) return error.AlreadyConfigured;42            if (candidates_to_copy.len == 0) return error.NoCandidates;43            if (candidates_to_copy.len > max_candidates) return error.TooManyCandidates;44            @memcpy(self.candidate_values[0..candidates_to_copy.len], candidates_to_copy);45            for (self.cost_values[0..candidates_to_copy.len]) |*cost| cost.* = .{};46            self.best_index = null;47            self.candidate_count = candidates_to_copy.len;48            self.config_index = 0;49            self.list = CandidateList.init(candidates_to_copy.len);50            self.rounds_complete = 0;51            self.skip_if_above = 0;52        }5354        pub fn candidates(self: *const Self) []const Config {55            std.debug.assert(self.hasCandidates());56            return self.candidate_values[0..self.candidate_count];57        }5859        pub fn costs(self: *Self) []CostDistribution {60            return self.cost_values[0..self.candidate_count];61        }6263        pub fn costsConst(self: *const Self) []const CostDistribution {64            return self.cost_values[0..self.candidate_count];65        }6667        pub fn nextConfig(self: *const Self) *const Config {68            std.debug.assert(self.hasCandidates());69            return &self.candidate_values[self.config_index];70        }7172        pub fn currentIndex(self: *const Self) usize {73            std.debug.assert(self.hasCandidates());74            return self.config_index;75        }7677        pub fn completedRounds(self: *const Self) usize {78            return self.rounds_complete;79        }8081        pub fn skipThreshold(self: *const Self) f64 {82            return self.skip_if_above;83        }8485        pub fn notifyCost(self: *Self, cost: u64) void {86            std.debug.assert(self.best() == null);87            std.debug.assert(self.hasCandidates());88            self.cost_values[self.config_index].notify(@floatFromInt(cost));89            const measured_index = self.config_index;90            const measured_cost = if (self.rounds_complete >= min_samples)91                self.cost_values[self.config_index].estimateCost()92            else93                0;94            self.config_index = self.list.next(self.config_index);95            if (measured_cost > self.skip_if_above) self.list.skip(measured_index);96            if (self.config_index <= measured_index) {97                self.rounds_complete += 1;98                if (self.rounds_complete >= min_samples) {99                    var best_cost = std.math.inf(f64);100                    var minimum_index: usize = 0;101                    for (self.cost_values[0..self.candidate_count], 0..) |*distribution, index| {102                        const estimate = distribution.estimateCost();103                        if (estimate < best_cost) {104                            best_cost = estimate;105                            minimum_index = index;106                        }107                    }108                    self.skip_if_above = best_cost * 1.25;109                    if (self.rounds_complete == 3 * min_samples / 2 + 1) {110                        self.best_index = minimum_index;111                    }112                }113            }114        }115116        pub fn shouldPrint(self: *const Self) bool {117            return self.rounds_complete > min_samples;118        }119    };120}

1pub const AutoTune = autotune.AutoTune;