perf!(embeddings): optimize thread allocation

- Prevent CPU oversubscription by aligning threads with core count
- Implement session-based scaling for parallel model execution
- Automate intra-op thread count based on available hardware
- Remove manual thread budget configuration

BREAKING CHANGE: Remove EMBEDDINGS_MAX_THREADS environment variable

Author: donhardman

embeddings/src/model/local.rs

@@ -32,8 +32,11 @@ use tokenizers::Tokenizer;
 /// Default batch size per ONNX forward pass.
 const DEFAULT_BATCH_SIZE: usize = 8;
 
-/// Default intra-op threads per session.
-const DEFAULT_INTRA_THREADS: usize = 4;
+/// Default number of parallel sessions: num_cpus / 2 (min 1).
+/// Each session gets 2 intra threads. Enough sessions to handle concurrent callers.
+fn default_num_sessions() -> usize {
+    (available_cpus() / 2).max(1)
+}
 
 fn batch_size() -> usize {
     std::env::var("EMBEDDINGS_BATCH_SIZE")
@@ -48,34 +51,22 @@ fn available_cpus() -> usize {
         .unwrap_or(2)
 }
 
-/// Max total ORT threads budget. Default: 2 × num_cpus (optimal oversubscription).
-/// Controls how many threads all sessions combined can use.
-fn max_threads() -> usize {
-    std::env::var("EMBEDDINGS_MAX_THREADS")
+/// Number of parallel ORT sessions.
+/// Default: num_cpus / 4 (min 1). On 32 cores = 8 sessions.
+fn num_sessions() -> usize {
+    std::env::var("EMBEDDINGS_NUM_SESSIONS")
         .ok()
         .and_then(|v| v.parse().ok())
-        .unwrap_or_else(|| available_cpus() * 2)
+        .unwrap_or_else(default_num_sessions)
 }
 
-/// Intra-op threads per session.
+/// Intra-op threads per session. Default: num_cpus / num_sessions.
+/// Total threads = num_sessions × intra_threads = num_cpus (no oversubscription).
 fn intra_threads() -> usize {
     std::env::var("EMBEDDINGS_INTRA_THREADS")
         .ok()
         .and_then(|v| v.parse().ok())
-        .unwrap_or(DEFAULT_INTRA_THREADS)
-}
-
-/// Number of parallel ORT sessions, derived from thread budget.
-/// total_threads = num_sessions × intra_threads ≤ max_threads
-fn num_sessions() -> usize {
-    let ns = std::env::var("EMBEDDINGS_NUM_SESSIONS")
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or_else(|| (max_threads() / intra_threads()).max(1));
-    // Cap so total threads don't exceed budget
-    let it = intra_threads();
-    let mt = max_threads();
-    (mt / it).max(1).min(ns)
+        .unwrap_or_else(|| (available_cpus() / num_sessions()).max(1))
 }
 
 /// Model architecture type - determines pooling strategy