tiny.pluck.bdd.LimitConfig

1pub const LimitConfig = struct {2    time_limit: ?f64,3    ite_limit: ?u64,4    start_time: ?i64,5    start_ite_count: u64,6    start_node_count: usize,7    start_ite_cache_count: usize,8    ite_cache_reservations: usize,9    time_limit_exceeded: bool,10    ite_limit_exceeded: bool,1112    pub fn init() LimitConfig {13        return LimitConfig{14            .time_limit = null,15            .ite_limit = null,16            .start_time = null,17            .start_ite_count = 0,18            .start_node_count = 0,19            .start_ite_cache_count = 0,20            .ite_cache_reservations = 0,21            .time_limit_exceeded = false,22            .ite_limit_exceeded = false,23        };24    }2526    pub fn startTimeLimit(self: *LimitConfig, limit: f64) void {27        self.time_limit = limit;28        self.start_time = time.milliTimestamp();29        self.time_limit_exceeded = false;30    }3132    pub fn stopTimeLimit(self: *LimitConfig) void {33        self.time_limit = null;34        self.start_time = null;35    }3637    pub fn startIteLimit(38        self: *LimitConfig,39        limit: u64,40        current_count: u64,41        node_count: usize,42        ite_cache_count: usize,43    ) void {44        std.debug.assert(self.ite_cache_reservations == 0);45        self.ite_limit = limit;46        self.start_ite_count = current_count;47        self.start_node_count = node_count;48        self.start_ite_cache_count = ite_cache_count;49        self.ite_cache_reservations = 0;50        self.ite_limit_exceeded = false;51    }5253    pub fn stopIteLimit(self: *LimitConfig) void {54        std.debug.assert(self.ite_cache_reservations == 0);55        self.ite_limit = null;56    }5758    pub fn checkTimeLimit(self: *LimitConfig) bool {59        if (self.time_limit) |limit| {60            if (self.start_time) |start| {61                const now = time.milliTimestamp();62                const elapsed_seconds = @as(f64, @floatFromInt(now - start)) / 1000.0;63                if (elapsed_seconds >= limit) {64                    self.time_limit_exceeded = true;65                    return true;66                }67            }68        }69        return false;70    }7172    pub fn checkIteLimit(self: *LimitConfig, current_count: u64) bool {73        if (self.ite_limit) |limit| {74            if (current_count -| self.start_ite_count >= limit) {75                self.ite_limit_exceeded = true;76                return true;77            }78        }79        return false;80    }8182    pub fn checkNodeGrowth(self: *LimitConfig, current_count: usize) bool {83        if (self.ite_limit) |limit| {84            const growth: u64 = @intCast(current_count -| self.start_node_count);85            if (growth >= limit) {86                self.ite_limit_exceeded = true;87                return true;88            }89        }90        return false;91    }9293    pub fn reserveIteCacheGrowth(self: *LimitConfig, current_count: usize) bool {94        if (self.ite_limit) |limit| {95            const growth: u64 = @intCast(current_count -| self.start_ite_cache_count);96            const reserved: u64 = @intCast(self.ite_cache_reservations);97            if (growth +| reserved >= limit) {98                self.ite_limit_exceeded = true;99                return true;100            }101            if (self.ite_cache_reservations == std.math.maxInt(usize)) {102                self.ite_limit_exceeded = true;103                return true;104            }105            self.ite_cache_reservations += 1;106        }107        return false;108    }109110    pub fn releaseIteCacheGrowth(self: *LimitConfig) void {111        if (self.ite_limit == null) return;112        std.debug.assert(self.ite_cache_reservations > 0);113        self.ite_cache_reservations -= 1;114    }115116    pub fn boundedAllocationFailed(self: *LimitConfig) bool {117        if (self.ite_limit == null) return false;118        self.ite_limit_exceeded = true;119        return true;120    }121};