MATLAB Engine API for Python: Persistent Session vs. Per-Call Startup for Low-Traffic Workloads

Answer

For workloads that invoke MATLAB functions only a handful of times per day, keeping a single persistent matlab.engine session is generally preferable. The initial cold‑start latency (~3–5 s) is avoided, the MATLAB process remains checked‑out so you avoid repeated license server traffic, and the memory footprint (≈200–400 MB) is modest compared to the startup cost.

Confirmed Facts

• Cold‑start latency for matlab.engine.start_matlab() in recent releases averages 3–5 seconds on typical workstations.
• An idle MATLAB Engine session consumes about 200–400 MB of resident memory; this stabilises after the first start.
• Each start/quit cycle checks out the MATLAB license again; frequent teardowns can raise contention on shared license servers.
• MATLAB Engine API does not automatically clear workspace state between calls, so a persistent session can carry over variables unless you explicitly clear them.
• License checkout limits (per‑user or per‑core) can be exceeded if you start and quit a session on every call.

Considerations

• Isolation: If your application requires strict separation of data between calls, a short‑lived session is safer, albeit with higher latency.
• Resource Availability: Persistent sessions keep a MATLAB process alive, which may interfere with system shutdown or exhaust available license seats if the Python process crashes.
• Concurrency: Sharing a single session across multiple Python workers can lead to race conditions; a lock or separate sessions per worker may be needed.

Recommended Approach for Low‑Traffic Workloads

1. Start the MATLAB Engine once at application startup and keep it alive for the life of the Python process.
2. Before each MATLAB call, clear the workspace if isolation is required:

   eng.eval('clear all', nargout=0)
   

3. On graceful shutdown, call eng.quit() to release the license and terminate the MATLAB process.
4. If the Python process may terminate unexpectedly, consider a watchdog script that periodically checks for orphaned MATLAB processes and kills them.

Measurement Steps

• Measure startup latency:

  import time, matlab.engine
  start = time.perf_counter()
  eng = matlab.engine.start_matlab()
  print('startup', time.perf_counter()-start)
  eng.quit()
  

• Measure resident memory using psutil:

  import psutil
  eng = matlab.engine.start_matlab()
  pid = eng._process.pid
  print('RAM', psutil.Process(pid).memory_info().rss / (1024**2), 'MB')
  eng.quit()
  

• Check license checkout count with lmstat before and after starting/quitting to confirm checkout behaviour.

Diagnostics to Clarify

To fine‑tune the recommendation, please confirm whether your environment uses a shared license server with per‑user limits. If so, persistent sessions help avoid hitting those limits.