Agentic AI
and the
Linux Kernel

/* include/linux/sched.h — added inside struct task_struct */

/**
 * agent_window_ns: duration in nanoseconds the "active window"
 * stays armed after each wakeup.  Set by userspace via sched_setattr().
 * 0 means feature disabled (default for all tasks).
 *
 * agent_min_util: minimum utilization signal (0–1024 SCHED_CAPACITY_SCALE)
 * injected into schedutil while the window is open.
 */
u64    agent_window_ns;   /* e.g. 5000000 = 5 ms window    */
u32    agent_min_util;    /* e.g. 512 = 50% of max freq    */

/* kernel/sched/sched.h — added inside struct rq */

u64    agent_active_until_ns;  /* ktime_get() deadline          */
u32    agent_min_util;         /* currently asserted util floor */

/* Helper: is the agent window currently open?
 * Called from schedutil and cpuidle — must be lockless and O(1). */
static inline bool rq_agent_window_active(const struct rq *rq, u64 now)
{
    return rq->agent_active_until_ns != 0 && now < rq->agent_active_until_ns;
}

/* Opt the current thread into agent latency mode.
 * agent_window_ns: how long to keep the CPU warm after each wakeup.
 * agent_min_util: minimum utilization floor (0–1024).               */
static int set_agent_latency(u64 window_ns, u32 min_util)
{
    struct sched_attr attr = {
        .size        = sizeof(attr),
        .sched_flags = SCHED_FLAG_AGENT_LATENCY,  /* new flag */
        .sched_agent_window_ns  = window_ns,
        .sched_agent_min_util   = min_util,
    };
    return syscall(SYS_sched_setattr, 0, &attr, 0);
}

int main(void)
{
    /* 5 ms window, 50% minimum frequency floor */
    set_agent_latency(5000000ULL, 512);

    while (1) {
        /* submit async work (io_uring, GPU dispatch, etc.) */
        io_uring_submit(&ring, sqe);

        /* block until completion — kernel stays warm for us */
        io_uring_wait_cqe(&ring, &cqe);

        /* fast compute: kernel CPU is already at target freq */
        process_result(cqe);
    }
}

/* In try_to_wake_up(), after the task is placed on the runqueue
 * and before the IRQ handler returns.
 * Executes in IRQ / softirq context — must be lock-free and fast.  */

static inline void task_agent_refresh_window(struct rq *rq,
                                              struct task_struct *p)
{
    u64 now, deadline;

    if (!p->agent_window_ns)          /* not an agent task: fast-exit */
        return;

    now      = ktime_get_ns();
    deadline = now + p->agent_window_ns;

    /* Extend or arm the window — always push out the deadline. */
    WRITE_ONCE(rq->agent_active_until_ns, deadline);
    WRITE_ONCE(rq->agent_min_util,        p->agent_min_util);

    /* Hint: prefer to wake on the task's last CPU to keep cache hot. */
    set_task_cpu(p, p->wake_cpu);
}

/* In the main try_to_wake_up() body — add a single call: */
task_agent_refresh_window(__this_cpu_ptr(&runqueues), p);

/* sugov_update_single_freq() — called by schedutil every DVFS tick.
 * 'util' is the raw PELT utilization signal.
 * We intercept it before it reaches the cpufreq driver.             */

static void sugov_update_single_freq(struct update_util_data *hook,
                                     u64 time, unsigned int flags)
{
    struct sugov_cpu *sg_cpu = container_of(hook, ...);
    struct rq        *rq     = cpu_rq(sg_cpu->cpu);
    unsigned long     util   = cpu_util_cfs(rq);   /* raw PELT */

    /* ── AGENT LATENCY PATCH ── */
    if (rq_agent_window_active(rq, time))
        util = max(util, (unsigned long)rq->agent_min_util);
    /* ── END PATCH ── */

    unsigned long freq = map_util_freq(util, sg_cpu->max,
                                        sg_cpu->max_cap);
    cpufreq_driver_fast_switch(policy, freq);
}

/* cpuidle_enter_state() — called just before the CPU halts.
 * 'index' is the C-state the governor selected (e.g. C6).
 * We veto deep states when the agent window is still open.          */

int cpuidle_enter_state(struct cpuidle_device *dev,
                        struct cpuidle_driver *drv, int index)
{
    struct rq *rq  = this_rq();
    u64        now = ktime_get_ns();

    /* ── AGENT LATENCY PATCH ── */
    if (rq_agent_window_active(rq, now)) {
        while (index > 0 &&
               drv->states[index].exit_latency > AGENT_LATENCY_IDLE_EXIT_LIMIT_US)
            index--;
        /* index now points to C1 or C0 — exit latency < 10 µs */
    }
    /* ── END PATCH ── */

    return drv->states[index].enter(dev, drv, index);
}

#!/usr/bin/bpftrace
/* Measures wakeup-to-run latency for agent-flagged tasks.
 * Attach: sudo bpftrace wakeup_to_run.bt                           */

kprobe:try_to_wake_up
{
    $task = (struct task_struct *)arg0;
    if ($task->sched_flags & SCHED_FLAG_AGENT_LATENCY) {
        @wake_ts[$task->pid] = nsecs;
    }
}

kprobe:finish_task_switch
{
    $prev = (struct task_struct *)arg0;
    $ts   = @wake_ts[pid];           /* pid of incoming task */
    if ($ts) {
        @wakeup_latency_us = hist((nsecs - $ts) / 1000);
        delete(@wake_ts[pid]);
    }
}

END { print(@wakeup_latency_us); clear(@wake_ts); }

#!/usr/bin/bpftrace
/* Tracks CPU frequency on the agent's CPU vs. elapsed wall time.
 * Run alongside the agent loop to visualise DVFS sagging.          */

kprobe:cpufreq_driver_fast_switch
{
    $cpu  = arg0;
    $freq = arg1;  /* kHz */

    if ($cpu == cpu()) {
        printf("t=%llu freq=%u\n", nsecs, $freq);
        @freq_khz = hist($freq);
    }
}

END { print(@freq_khz); }

#!/usr/bin/bpftrace
/* Records which C-state is entered before each agent wakeup.
 * Deep C-states (C6+) with exit_latency > 100 µs are flagged.     */

kprobe:cpuidle_enter_state
{
    $dev   = (struct cpuidle_device *)arg0;
    $drv   = (struct cpuidle_driver *)arg1;
    $index = arg2;
    $lat   = $drv->states[$index].exit_latency;   /* µs */

    @cstate_hist = hist($index);
    @exit_lat_us = hist($lat);

    if ($lat > 100) {
        @deep_sleeps = count();
        printf("DEEP: cpu=%d C-state=%d exit_lat=%d µs\n",
               $dev->cpu, $index, $lat);
    }
}

END {
    print(@cstate_hist);
    print(@exit_lat_us);
    printf("Total deep-sleep entries: %llu\n", @deep_sleeps);
}

# 1. Build the benchmark
cd selftests && make

# 2. Baseline: no patch
./agent_loop --steps 1000 --interval-us 500 | tee baseline.txt

# 3. Apply kernel patch and rebuild
git apply ../patches/0000-kernel-agent-latency-control-plane-rfc.patch
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
sudo insmod agent_latency.ko

# 4. With patch: 5 ms window, 50% util floor
./agent_loop --agent-latency --window-ns 5000000 --min-util 512 \
             --steps 1000 --interval-us 500 | tee patched.txt

# 5. Attach eBPF tracing (in a second terminal)
sudo bpftrace tools/bpftrace/wakeup_to_run.bt
sudo bpftrace tools/bpftrace/dvfs_ramp.bt
sudo bpftrace tools/bpftrace/cstate_audit.bt

# 6. Compare p99 latencies
awk '/p99/{print}' baseline.txt patched.txt