Greptile Overview

Summary

Replaces Semaphore(1) with Lock to fix concurrent engine start/stop issues, but introduces critical deadlock bug.

Major Issues:

• astart() acquires mutex but never releases it, causing deadlock on any subsequent call
• astop() logic is broken - checks if mutex is locked but relies on manual acquire/release pattern
• The implementation doesn't actually solve the original problem described in the PR

Original Issue (from PR):
The author reports that multiple concurrent async with engine: calls increment a semaphore counter beyond its limit. However, Semaphore(1) acts as a binary semaphore/mutex - it shouldn't allow counter > 1.

Root Cause:
The original code's semaphore pattern was correct. The real issue is likely that multiple tasks call __aenter__() → astart(), and the semaphore correctly serializes these calls. But the implementation needs proper context manager pattern (async with) not manual acquire/release.

Confidence Score: 0/5

• This PR will cause immediate deadlocks in production and must not be merged
• Score reflects critical logic error where mutex is acquired but never released in astart(), causing permanent deadlock on second engine start. This makes the async context manager pattern (async with engine:) completely unusable.
• libs/infinity_emb/infinity_emb/engine.py requires complete reimplementation of the locking mechanism

Important Files Changed

File Analysis

Sequence Diagram

sequenceDiagram
    participant Job1 as Job 1
    participant Job2 as Job 2
    participant Engine as AsyncEmbeddingEngine
    participant Mutex as _running_mutex
    participant Handler as BatchHandler
    
    Note over Job1,Job2: Multiple async with engine: contexts
    
    Job1->>Engine: __aenter__()
    Engine->>Engine: astart()
    Engine->>Mutex: acquire()
    Mutex-->>Engine: acquired
    Engine->>Engine: Check not self.running
    Engine->>Engine: Set self.running = True
    Engine->>Handler: spawn()
    Handler-->>Engine: started
    Note over Engine,Mutex: ❌ DEADLOCK: Lock never released!
    Engine-->>Job1: enters context
    
    Job2->>Engine: __aenter__()
    Engine->>Engine: astart()
    Engine->>Mutex: acquire()
    Note over Mutex: ❌ BLOCKED FOREVER: waiting for lock
    
    Job1->>Engine: __aexit__()
    Engine->>Engine: astop()
    Engine->>Mutex: locked()?
    Note over Engine: Lock is held, continues
    Engine->>Engine: Check self.running
    Engine->>Handler: shutdown()
    Engine->>Mutex: release()
    Note over Mutex: Lock finally released
    
    Note over Job2: Still blocked in astart()!

_{1 file reviewed, 3 comments}

_{Edit Code Review Agent Settings | Greptile}