graph: Replace std::sync::RwLock with parking_lot::RwLock in LoadManager

These locks are accessed on every GraphQL query, so using the faster
parking_lot::RwLock reduces lock contention in the query path.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lutter

graph/src/data/graphql/load_manager.rs

@@ -4,9 +4,11 @@ use prometheus::core::GenericCounter;
 use rand::{prelude::Rng, rng};
 use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 
+use crate::parking_lot::RwLock;
+
 use crate::components::metrics::{Counter, GaugeVec, MetricsRegistry};
 use crate::components::store::{DeploymentId, PoolWaitStats};
 use crate::data::graphql::shape_hash::shape_hash;
@@ -57,7 +59,7 @@ impl ShardEffort {
     }
 
     pub fn add(&self, shard: &str, qref: QueryRef, duration: Duration, gauge: &GaugeVec) {
-        let mut inner = self.inner.write().unwrap();
+        let mut inner = self.inner.write();
         inner.add(qref, duration);
         gauge
             .with_label_values(&[shard])
@@ -70,7 +72,7 @@ impl ShardEffort {
     /// data for the particular query, return `None` as the effort
     /// for the query
     pub fn current_effort(&self, qref: &QueryRef) -> (Option<Duration>, Duration) {
-        let inner = self.inner.read().unwrap();
+        let inner = self.inner.read();
         let total_effort = inner.total.duration();
         let query_effort = inner.effort.get(qref).map(|stats| stats.duration());
         (query_effort, total_effort)
@@ -381,7 +383,7 @@ impl LoadManager {
 
         let qref = QueryRef::new(deployment, shape_hash);
 
-        if self.jailed_queries.read().unwrap().contains(&qref) {
+        if self.jailed_queries.read().contains(&qref) {
             return if ENV_VARS.load_simulate {
                 Proceed
             } else {
@@ -426,7 +428,7 @@ impl LoadManager {
                 "query_effort_ms" => query_effort,
                 "total_effort_ms" => total_effort,
                 "ratio" => format!("{:.4}", query_effort/total_effort));
-                self.jailed_queries.write().unwrap().insert(qref);
+                self.jailed_queries.write().insert(qref);
                 return if ENV_VARS.load_simulate {
                     Proceed
                 } else {
@@ -465,7 +467,7 @@ impl LoadManager {
     }
 
     fn kill_state(&self, shard: &str) -> (f64, Instant) {
-        let state = self.kill_state.get(shard).unwrap().read().unwrap();
+        let state = self.kill_state.get(shard).unwrap().read();
         (state.kill_rate, state.last_update)
     }
 
@@ -505,7 +507,7 @@ impl LoadManager {
                 kill_rate = (kill_rate - KILL_RATE_STEP_DOWN).max(0.0);
             }
             let event = {
-                let mut state = self.kill_state.get(shard).unwrap().write().unwrap();
+                let mut state = self.kill_state.get(shard).unwrap().write();
                 state.kill_rate = kill_rate;
                 state.last_update = now;
                 state.log_event(now, kill_rate, overloaded)