The action queue

The contract#

private static final int MAX_QUEUED = 128;
private static final ConcurrentLinkedQueue<InputAction.Stamped> QUEUE = new ConcurrentLinkedQueue<>();
private static final AtomicInteger COUNT = new AtomicInteger(0);
private static final Object LOCK = new Object();

Why the counter exists#

ConcurrentLinkedQueue.size() is O(n). The counter makes the size a constant time read, which matters because the overlay and the settings screen read it while the poller is running.

Why the lock exists#

An earlier version incremented the counter outside the lock. The polling thread could then be between its increment and its offer() when clear() ran: the polled event was lost, but the count still said "one less", so the queue could grow past 128 and defeat the bounded-backlog guarantee the architecture depends on.

public static boolean queue(InputAction action, InputAction.Origin origin) {
    synchronized (LOCK) {
        if (COUNT.get() >= MAX_QUEUED) return false;
        QUEUE.offer(InputAction.Stamped.of(action, origin));
        COUNT.incrementAndGet();
        return true;
    }
}

The stamped record#

public record Stamped(InputAction action, long capturedAt, Origin origin) {
    public static Stamped of(InputAction action, Origin origin) {
        return new Stamped(action, System.nanoTime(), origin);
    }
}

The capture timestamp is taken when the action is queued, which is as close to the physical press as the mod can measure. LatencyProfiler compares it with the drain time.

Pending physical events#

public static int pendingPhysical() {
    synchronized (LOCK) {
        int physical = 0;
        for (InputAction.Stamped stamped : QUEUE) {
            if (!stamped.isReplay()) physical++;
        }
        return physical;
    }
}

The replay recorder calls this. When the number is above zero, playback holds back and rewinds its clock slightly, so a recording can never be injected on top of a live click.

When the queue is cleared#

What happens when it is full#

The action is rejected. InputEventDispatcher.submit counts it as a dropped action and returns false. The caller does not retry — the physical press is lost.

In practice, 128 entries is far more than a tick can consume unless the client is severely behind: at 1000 Hz, a tick that takes 128 ms would be needed to fill it.

The suppression tokens#

Two tick-scoped tokens live next to the queue:

private static final AtomicInteger TICK = new AtomicInteger(1);
private static volatile int attackHandledTick = -1;
private static volatile int useHandledTick = -1;

beginTick() expires the tokens from earlier ticks. A token carries the tick id it was issued in, so a missed or reordered call can never suppress a legitimate attack on a later tick.

Reading the queue#

Related pages#

• Action semantics — what each action does.
• Input pipeline — the full path.
• Replay and logs — how replay uses the queue.