pyqt-code-editor 1.0.5__tar.gz → 1.1.0__tar.gz

{pyqt_code_editor-1.0.5 → pyqt_code_editor-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyqt_code_editor
-Version: 1.0.5
+Version: 1.1.0
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>

{pyqt_code_editor-1.0.5 → pyqt_code_editor-1.1.0}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '1.0.5'
+__version__ = '1.1.0'

{pyqt_code_editor-1.0.5 → pyqt_code_editor-1.1.0}/pyqt_code_editor/worker/manager.py

@@ -5,9 +5,11 @@ from .process import main_worker_process_function
 from .. import watchdog, settings
 logger = logging.getLogger(__name__)
 STOP_UNUSED_INTERVAL = 10
+MAX_CONCURRENT_STARTING = 2
 _last_stop_unused_time = 0
 _workers = {}  # pid -> {"process", "request_queue", "result_queue", "is_free"}
 _stopping = {}  # pid -> same shape as _workers, but already asked to quit
+_starting = set()  # pids of workers created but not yet proven alive-and-useful
 suspended = False
 
 
@@ -36,29 +38,24 @@ def _cleanup_dead_workers():
             w["process"].join(timeout=1)
         except Exception as e:
             logger.warning(f"Error joining dead worker {pid}: {e}")
+        # If this worker died before ever completing its first request, it
+        # was still occupying a "starting" slot; free that slot up.
+        _starting.discard(pid)
 
 
-def send_worker_request(**data) -> (Queue, int):
+def _start_new_worker(is_free: bool = False) -> int:
     """
-    Send a request to a worker process. If a free worker is available,
-    reuse it; otherwise create a new one. Return (result_queue, pid).
+    Create and start a single new worker process, send it the current
+    settings, and register it in _workers and _starting.
 
-    The caller can poll the result_queue for responses, and once done,
-    call mark_worker_as_free(pid) to release this worker for future use.
+    `is_free` controls whether the worker is immediately marked as
+    available for reuse (used by start_worker_pool(), which starts idle
+    workers ahead of time) or not (used by send_worker_request(), which
+    immediately queues a real request on it).
 
-    If workers are suspended, return (None, None).
+    Returns the new worker's pid. Does not check MAX_CONCURRENT_STARTING;
+    callers are responsible for that.
     """
-    if suspended:
-        return None, None
-    # 1. Look for an existing free worker
-    for pid, w in list(_workers.items()):
-        if w["is_free"] and w["process"].is_alive():
-            logger.info(f"Reusing free worker {pid} (of {len(_workers)}) for request {list(data.keys())}")
-            w["is_free"] = False
-            w["request_queue"].put(data)
-            return w["result_queue"], pid
-
-    # 2. If no free worker was found, create a new one.
     request_queue = Queue()
     result_queue = Queue()
     p = Process(target=main_worker_process_function,
@@ -71,27 +68,108 @@ def send_worker_request(**data) -> (Queue, int):
         "process": p,
         "request_queue": request_queue,
         "result_queue": result_queue,
-        "is_free": False,
+        "is_free": is_free,
     }
+    _starting.add(pid)
 
-    logger.info(f"Creating new worker {pid} for request {data['action']}")
+    logger.info(f"Created new worker {pid} (is_free={is_free})")
     settings_action = {'action': 'set_settings',
                        'settings': {name: value for name, value in settings}}
     request_queue.put(settings_action)
-    # 3. Send the request, return the new worker's result queue and pid.
-    request_queue.put(data)
-    return result_queue, pid
+    return pid
+
+
+def send_worker_request(**data) -> (Queue, int):
+    """
+    Send a request to a worker process. If a free worker is available,
+    reuse it; otherwise create a new one. Return (result_queue, pid).
+
+    The caller can poll the result_queue for responses, and once done,
+    call mark_worker_as_free(pid) to release this worker for future use.
+
+    If workers are suspended, return (None, None).
+
+    We also decline to create a new worker (returning (None, None)) if
+    MAX_CONCURRENT_STARTING workers are already "starting" -- i.e. have
+    been created but haven't yet completed a first successful round-trip
+    (see _starting / mark_worker_as_free()). This caps how many freshly
+    spawned, still-booting worker processes can pile up at once. A single
+    worker creation still pays the normal (and, on Windows, sometimes
+    substantial) process-creation cost on the GUI thread, but we avoid the
+    much worse case of several such creations happening back-to-back and
+    competing for CPU/disk/antivirus scanning at the same time.
+
+    Note that start_worker_pool() shares the same _starting bookkeeping,
+    so a pool worker that is still booting also counts against this cap.
+    """    
+    if suspended:
+        return None, None
+    # 1. Look for an existing free worker. This also picks up workers that
+    # were started ahead of time by start_worker_pool(), whether or not
+    # they have finished booting yet.
+    for pid, w in list(_workers.items()):
+        if w["is_free"] and w["process"].is_alive():
+            logger.info(f"Reusing free worker {pid} (of {len(_workers)}) for request {list(data.keys())}")
+            w["is_free"] = False
+            w["request_queue"].put(data)
+            return w["result_queue"], pid
+
+    # 2. If no free worker was found, create a new one -- unless too many
+    # workers are already in the process of starting up.
+    if len(_starting) >= MAX_CONCURRENT_STARTING:
+        logger.info(
+            f"Declining to start a new worker for request "
+            f"{list(data.keys())}; {len(_starting)} worker(s) already "
+            "starting."
+        )
+        return None, None
+
+    pid = _start_new_worker(is_free=False)
+    w = _workers[pid]
+    logger.info(f"Sending request {data['action']} to newly created worker {pid}")
+    w["request_queue"].put(data)
+    return w["result_queue"], pid
+
+def start_worker_pool():
+    """
+    Proactively start up to MAX_CONCURRENT_STARTING idle worker processes,
+    so that a free (or at least already-booting) worker is more likely to
+    be available by the time the user actually triggers a request -- e.g.
+    right when they start typing.
+
+    Workers started here are tracked in _starting exactly like workers
+    created on-demand by send_worker_request(), and are marked as free
+    immediately, so send_worker_request() will pick them up as soon as
+    they exist -- whether or not they've finished booting yet.
+
+    Intended to be called at strategic moments (e.g. app startup, after
+    resume(), or when a new editor is opened), not from a tight loop: each
+    call may create up to MAX_CONCURRENT_STARTING new processes on top of
+    whatever is already starting.
+    """
+    if suspended:
+        logger.info("Not starting worker pool because workers are suspended.")
+        return
+    for _ in range(MAX_CONCURRENT_STARTING):
+        _start_new_worker(is_free=True)
+    logger.info(f"Started worker pool of {MAX_CONCURRENT_STARTING} worker(s).")
 
 def mark_worker_as_free(pid: int):
     """
     Mark a previously-used worker process (identified by pid)
     as free for reuse. If the worker has died, clean it up instead.
+
+    This is also the point at which a worker is considered to have proven
+    itself alive-and-useful (it has completed a request), so we release
+    its "starting" slot here if it still held one -- whether it succeeded
+    or died in the process.
     """
     w = _workers.get(pid)
     if w is None:
         return
     if w["process"].is_alive():
         w["is_free"] = True
+        _starting.discard(pid)
         logger.info(f"Marking worker {pid} as free")
     else:
         # The worker died while handling a request; clean up its resources
@@ -99,6 +177,7 @@ def mark_worker_as_free(pid: int):
         _workers.pop(pid)
         _close_worker_queues(w)
         w["process"].join(timeout=1)
+        _starting.discard(pid)
 
 def check_worker_alive(pid: int) -> bool:
     w = _workers.get(pid)
@@ -128,7 +207,7 @@ def reap_stopping_workers():
             logger.warning(f"Error joining stopped worker {pid}: {e}")
         _close_worker_queues(w)
 
-def stop_unused_workers(max_free: int = 1, force: bool = False):
+def stop_unused_workers(max_free: int = 3, force: bool = False):
     """
     Request that free worker processes stop until there is at most
     'max_free' free processes left. This keeps us from accumulating too
@@ -143,6 +222,11 @@ def stop_unused_workers(max_free: int = 1, force: bool = False):
     joining a process that hasn't exited yet can block for a noticeable
     amount of time, especially on Windows, and this function is typically
     called from a periodic timer on the main/GUI thread.
+
+    Note: if max_free is set lower than MAX_CONCURRENT_STARTING, workers
+    just started by start_worker_pool() may be asked to stop again before
+    they ever get used. The default of 3 leaves headroom above
+    MAX_CONCURRENT_STARTING (2).
     """
     global _last_stop_unused_time
     if not force and time.time() - _last_stop_unused_time < STOP_UNUSED_INTERVAL:
@@ -197,6 +281,8 @@ def stop_all_workers():
             logger.warning(f"Error joining stopping worker {pid}: {e}")
         _close_worker_queues(w)
         del _stopping[pid]
+    # Nothing is left running, so no worker can still be "starting".
+    _starting.clear()
     logger.info("All workers stopped.")