Lower-Latency Real-Time Optimization

You're a robotics engineer at Pickle Robot working on the gripper controller for a trailer-unloading arm. The function below runs inside the hard real-time control loop at 1kHz, computing a grip force adjustment from the current joint state. Under load testing it mostly hits its 1ms budget, but every so often a single control cycle takes several milliseconds, long enough to miss the deadline and cause a visible jerk in the gripper.

#include <vector>
#include <mutex>
#include <iostream>

struct JointState {
    double positions[7];
    double velocities[7];
    double torques[7];
};

struct GripperConfig {
    double gain;
};

std::mutex g_configMutex;
GripperConfig g_config;

std::vector<double> computeGripAdjustment(JointState state, double targetForce) {
    std::vector<double> adjustment;

    std::lock_guard<std::mutex> lock(g_configMutex);

    for (int i = 0; i < 7; i++) {
        double error = targetForce - state.torques[i];
        adjustment.push_back(error * g_config.gain);
    }

    std::cout << "grip error computed" << std::endl;

    return adjustment;
}

Explain exactly why this occasionally misses its 1ms real-time budget, and how you'd rework it to keep the worst case bounded, not just the average case.