Speed up small reads on the Raw.get_data hot path

get_data resolves picks=None to arange directly instead of going through
string-based channel-name machinery on every call, and _mult_cal_one
fuses gather, type-cast, and calibration into a single pass instead of
three. Adds an internal batched window reader (Raw._get_windows) that
shares per-call setup across windows and can fill a caller-provided
float32/float64 buffer.

Author: bruAristimunha

mne/_fiff/pick.py

@@ -1334,6 +1334,18 @@ def _picks_to_idx(
         )
         raise TypeError(msg)
     del extra_repr
+    # Fast path: an integer ndarray with all values already in range needs no
+    # copy or further checks. This matters for callers resolving picks on
+    # every access (e.g., Raw.get_data in deep-learning training loops).
+    if (
+        picks.dtype.kind == "i"
+        and picks.size
+        and picks.min() >= 0
+        and picks.max() < n_chan
+    ):
+        if return_kind:
+            return picks, picked_ch_type_or_generic
+        return picks
     picks = picks.astype(int)
 
     #

mne/_fiff/utils.py

@@ -73,22 +73,27 @@ def _find_channels(ch_names, ch_type="EOG"):
 
 def _mult_cal_one(data_view, one, idx, cals, mult):
     """Take a chunk of raw data, multiply by mult or cals, and store."""
-    one = np.asarray(one, dtype=data_view.dtype)
     assert data_view.shape[1] == one.shape[1], (
         data_view.shape[1],
         one.shape[1],
     )  # noqa: E501
     if mult is not None:
+        one = np.asarray(one, dtype=data_view.dtype)
         assert mult.ndim == one.ndim == 2
         data_view[:] = mult @ one[idx]
     else:
         assert cals is not None
         if isinstance(idx, slice):
-            data_view[:] = one[idx]
+            # Hot path: gather + type-cast + calibration in a single pass,
+            # without materializing an intermediate float64 copy of `one`
+            # (`one[idx]` is a view for basic slices). Numerically identical
+            # to cast-then-scale because both are elementwise.
+            np.multiply(one[idx], cals.reshape(-1, 1), out=data_view,
+                        casting="unsafe")
         else:
-            # faster than doing one = one[idx]
+            one = np.asarray(one, dtype=data_view.dtype)
             np.take(one, idx, axis=0, out=data_view)
-        data_view *= cals
+            data_view *= cals
 
 
 def _blk_read_lims(start, stop, buf_len):

mne/io/base.py

@@ -877,6 +877,37 @@ def _parse_get_set_params(self, item):
 
         return sel, start, stop
 
+    def _get_windows(self, starts, width, *, out=None, sel=None):
+        """Read many equal-width windows with setup shared across them."""
+        starts = np.atleast_1d(np.asarray(starts, dtype=np.int64)).ravel()
+        width = int(width)
+        if width <= 0:
+            raise ValueError(f"width must be positive, got {width}")
+        n_times = self.n_times
+        bad = (starts < 0) | (starts + width > n_times)
+        if bad.any():
+            raise ValueError(
+                f"window out of bounds at index {int(np.flatnonzero(bad)[0])}"
+            )
+        n_out = self.info["nchan"] if sel is None else len(sel)
+        if out is None:
+            out = np.empty((len(starts), n_out, width), dtype=self._dtype)
+        elif out.shape != (len(starts), n_out, width):
+            raise ValueError(
+                f"out has shape {out.shape}, need {(len(starts), n_out, width)}"
+            )
+        elif out.dtype not in (np.float64, np.float32):
+            raise ValueError(
+                f"out dtype must be float64 or float32, got {out.dtype}"
+            )
+        for j, s0 in enumerate(starts):
+            self._read_segment(
+                start=int(s0), stop=int(s0) + width,
+                sel=sel,
+                data_buffer=out[j],
+            )
+        return out
+
     def __getitem__(self, item):
         """Get raw data and times.
 
@@ -1001,7 +1032,14 @@ def get_data(
             stop, types=("int-like", None), item_name="stop", type_name="int, None"
         )
 
-        picks = _picks_to_idx(self.info, picks, "all", exclude=())
+        if picks is None:
+            # fast path: equivalent to _picks_to_idx(info, None, "all",
+            # exclude=()) but avoids channel-name resolution on every call,
+            # which matters for workloads making many small reads (e.g.,
+            # deep-learning training loops)
+            picks = np.arange(self.info["nchan"])
+        else:
+            picks = _picks_to_idx(self.info, picks, "all", exclude=())
 
         # Get channel factors for conversion into specified unit
         # (vector of ones if no conversion needed)

mne/utils/mixin.py

@@ -575,8 +575,13 @@ def _handle_tmin_tmax(self, tmin, tmax):
             type_name="int, float, None",
         )
 
-        # handle tmin/tmax as start and stop indices into data array
-        n_times = self.times.size
+        # handle tmin/tmax as start and stop indices into data array.
+        # Prefer an integer n_times (available on Raw); falling back to
+        # times.size there would materialize the full time vector on every
+        # call, which dominates the cost of many small get_data() reads.
+        n_times = getattr(self, "n_times", None)
+        if n_times is None:
+            n_times = self.times.size
         start = 0 if tmin is None else self.time_as_index(tmin)[0]
         stop = n_times if tmax is None else self.time_as_index(tmax)[0]