Vectorized EDF/BDF window decode fast path

Uniform-sampling-rate EDF/BDF windows decode through a strided gather
plus an optional-numba kernel writing calibrated samples directly into
the caller's output buffer, replacing the per-channel Python loop.
Big-endian chunks are byteswapped to native order first; uniform stim
channels apply the legacy truncating bitmask on the fast path;
projector/compensation reads keep the exact legacy route. EDF/BDF/GDF
file handles persist per process (PID-keyed LRU).

Author: bruAristimunha

mne/io/edf/_bdf_numba.py

@@ -0,0 +1,33 @@
+"""Numba-accelerated BDF (24-bit little-endian) sample decoding.
+
+Optional acceleration: falls back to the vectorized-numpy path in
+``mne.io.edf.edf._read_ch`` when numba is unavailable.
+"""
+
+# Authors: The MNE-Python contributors.
+# License: BSD-3-Clause
+# Copyright the MNE-Python contributors
+
+import numpy as np
+
+from ..._numba import jit
+
+
+@jit()
+def decode_int24(buf):  # pragma: no cover
+    """Decode packed 24-bit little-endian samples to int32.
+
+    ``buf`` is a ``(n_samples, 3)`` uint8 array whose rows hold the low,
+    middle, and high bytes of each signed sample.
+    """
+    n = buf.shape[0]
+    out = np.empty(n, dtype=np.int32)
+    for i in range(n):
+        # plain-Python integer arithmetic so the non-numba fallback follows
+        # the same semantics as the jitted version (values stay within
+        # [-2**23, 2**23) after the sign fix, so int32 stores never overflow)
+        v = int(buf[i, 0]) | (int(buf[i, 1]) << 8) | (int(buf[i, 2]) << 16)
+        if v >= (1 << 23):
+            v -= 1 << 24
+        out[i] = v
+    return out

mne/io/edf/_edf_numba.py

@@ -0,0 +1,69 @@
+"""Numba-accelerated EDF/BDF digital-to-physical window decoding.
+
+Optional acceleration: falls back to the vectorized-numpy path in
+``mne.io.edf.edf._read_segment_file`` when numba is unavailable.
+"""
+
+# Authors: The MNE-Python contributors.
+# License: BSD-3-Clause
+# Copyright the MNE-Python contributors
+
+from ..._numba import jit
+
+
+@jit(fastmath=False)
+def decode_window(digital, cal_v, off_v, gain_v, out):  # pragma: no cover
+    """Decode a block of digital samples to physical units.
+
+    ``digital`` is a ``(k, n_blocks, buf_len)`` (possibly strided) integer
+    view of raw digital samples; ``cal_v``, ``off_v``, and ``gain_v`` are
+    length-``k`` float64 vectors; ``out`` is a ``(k, n_blocks * buf_len)``
+    float64 array whose rows are filled with blocks concatenated along the
+    sample axis such that::
+
+        out[i, b * buf_len + j] = ((digital[i, b, j] * cal[i]) + off[i]) * gain[i]
+
+    replicating exactly the operation order of the vectorized-numpy fallback
+    (hence ``fastmath=False``: no FMA contraction or reassociation is
+    allowed, so results are bit-identical to separate multiply/add rounding).
+    """
+    k = digital.shape[0]
+    n_blk = digital.shape[1]
+    n_smp = digital.shape[2]
+    for i in range(k):
+        cal = cal_v[i]
+        off = off_v[i]
+        gain = gain_v[i]
+        out_i = out[i]
+        for b in range(n_blk):
+            base = b * n_smp
+            for j in range(n_smp):
+                out_i[base + j] = ((digital[i, b, j] * cal) + off) * gain
+
+
+@jit(fastmath=False)
+def decode_window_into(
+    dst, digital, cal_v, off_v, gain_v, s0, w
+):  # pragma: no cover
+    """Decode into a possibly-strided 2-D destination.
+
+    ``dst`` is ``(k, w)`` with arbitrary strides (e.g., a column slice of the
+    caller's output buffer); ``digital`` is the ``(k, n_blocks, buf_len)``
+    strided integer view covering whole data records; ``s0`` is the first
+    sample to take from that view and ``w`` the number of samples to write,
+    so edge records at window boundaries are handled without temporaries.
+    Elementwise op order is identical to :func:`decode_window`.
+    """
+    k = digital.shape[0]
+    n_smp = digital.shape[2]
+    for i in range(k):
+        cal = cal_v[i]
+        off = off_v[i]
+        gain = gain_v[i]
+        dst_i = dst[i]
+        dig_i = digital[i]
+        for t in range(w):
+            g = s0 + t
+            b = g // n_smp
+            j = g - b * n_smp
+            dst_i[t] = ((dig_i[b, j] * cal) + off) * gain

mne/io/edf/_open.py

@@ -1,21 +1,64 @@
 # Authors: The MNE-Python contributors.
 # License: BSD-3-Clause
-# Copyright the MNE-Python contributors.
+# Copyright the MNE-Python contributors
 
+import os
 from pathlib import Path
 
 from ..._fiff.open import _NoCloseRead
 from ...utils import _file_like, _validate_type, logger
 
+# Persistent read handles for EDF/BDF/GDF files. Readers seek before every
+# read, so a shared handle is safe; keying by PID keeps forked worker
+# processes (e.g., PyTorch DataLoader workers) from sharing file-offset state
+# through an inherited descriptor.
+_HANDLE_CACHE = {}
+_MAX_HANDLES = 8
+
+
+class _NoCloseCached(_NoCloseRead):
+    """A file object whose context manager detaches instead of closing.
+
+    Used for handles shared through the per-process LRU cache: leaving the
+    reader's ``with`` block must not close a descriptor other reads may still
+    use.
+    """
+
+    def close(self):  # noqa: D102
+        pass
+
+    def __exit__(self, *args):  # noqa: D105
+        # detach rather than close; the cache owns the lifetime
+        return False
+
+
+def _get_cached_fid(fname):
+    """Return a persistent binary handle for *fname* (per process)."""
+    key = (os.getpid(), str(fname))
+    hit = _HANDLE_CACHE.get(key)
+    if hit is not None:
+        hit.seek(0)  # match fresh-open semantics
+        return hit
+    fid = open(fname, "rb")
+    cached = _NoCloseCached(fid)
+    _HANDLE_CACHE[key] = cached
+    while len(_HANDLE_CACHE) > _MAX_HANDLES:
+        old_key = next(iter(_HANDLE_CACHE))
+        try:
+            _HANDLE_CACHE.pop(old_key).fid.close()
+        except Exception:
+            pass
+    return cached
+
 
 def _gdf_edf_get_fid(fname, **kwargs):
     """Open a EDF/BDF/GDF file with no additional parsing."""
     if _file_like(fname):
         logger.debug("Using file-like I/O")
         fid = _NoCloseRead(fname)
         fid.seek(0)
-    else:
-        _validate_type(fname, [Path, str], "fname", extra="or file-like")
-        logger.debug("Using normal I/O")
-        fid = open(fname, "rb", **kwargs)  # Open in binary mode
-    return fid
+        return fid
+    _validate_type(fname, [Path, str], "fname", extra="or file-like")
+    logger.debug("Using normal I/O")
+    kwargs.pop("buffering", None)  # cached handle manages its own buffering
+    return _get_cached_fid(Path(fname))