From e8375c0272facfa175fa9633c35ea27b69cfa317 Mon Sep 17 00:00:00 2001 From: Riccardo Date: Thu, 26 Mar 2026 22:13:19 +0000 Subject: [PATCH 1/6] refactor: defer sentinel replacement from parser to preprocessing layer DragerBinParser.parse() now returns the raw memmap directly without copying to RAM or replacing sentinel values (-1000.0, 0xFF7FC99E). Sanitization is the responsibility of the preprocessing layer, which ensures files are never loaded into RAM during batch parsing. - Remove steps 6-8 (copy + replace_sentinels for pixels and Medibus) - Remove _FLOAT_SENTINELS/_BIT_SENTINELS/_replace_no_data_sentinels imports - Remove __init__ sentinel lists (no longer needed in parser) - Update test: sentinel values are now preserved in raw parser output --- src/fasteit/parsers/draeger/bin/bin_parser.py | 34 ++++--------------- tests/test_bin_parser.py | 9 +++-- 2 files changed, 13 insertions(+), 30 deletions(-) diff --git a/src/fasteit/parsers/draeger/bin/bin_parser.py b/src/fasteit/parsers/draeger/bin/bin_parser.py index 9f9ba7b..d7c23b3 100644 --- a/src/fasteit/parsers/draeger/bin/bin_parser.py +++ b/src/fasteit/parsers/draeger/bin/bin_parser.py @@ -12,11 +12,8 @@ from fasteit.parsers.errors import AmbiguousFormatError, UnsupportedFrameSizeError from .bin_utils import ( - _BIT_SENTINELS, - _FLOAT_SENTINELS, estimate_sampling_frequency_hz, normalize_frame_slice, - replace_no_data_sentinels, ) # Default sampling frequency used when fs cannot be estimated from timestamps. @@ -43,10 +40,6 @@ class DragerBinParser(BaseParser): https://github.com/EIT-ALIVE/eitprocessing """ - def __init__(self) -> None: - self._float_sentinels = _FLOAT_SENTINELS - self._bit_sentinels = _BIT_SENTINELS - def validate(self, path: Path) -> bool: """Return True if file exists, is non-empty, and has a known frame size.""" path = Path(path) @@ -119,35 +112,20 @@ def parse( else: warnings_list = [] - # ── 6. Copy memmap to writable array ────────────────────────────────── - frames = mapped_frames.copy() - - # ── 7. Sanitize pixels: vectorized over all frames at once ──────────── - frames["pixels"] = replace_no_data_sentinels( - mapped_frames["pixels"], - self._float_sentinels, - self._bit_sentinels, - ) - - # ── 8. Sanitize Medibus data if present (EXT format only) ───────────── - if spec.medibus_fields is not None: - frames["medibus_data"] = replace_no_data_sentinels( - frames["medibus_data"], - self._float_sentinels, - self._bit_sentinels, - ) - - # ── 9. Build aux_signals dict: {signal_name → array shape (N,)} ────── + # ── 6. Build aux_signals dict: {signal_name → array shape (N,)} ────── + # Note: sentinel values (e.g. -1000.0, 0xFF7FC99E) are NOT replaced here. + # Sanitization is deferred to the preprocessing layer so that the memmap + # is never copied to RAM during parsing (lazy loading preserved). aux_signals = None if spec.medibus_fields is not None: aux_signals = { - field_name: frames["medibus_data"][:, field_idx] + field_name: mapped_frames["medibus_data"][:, field_idx] for field_idx, field_name in enumerate(spec.medibus_fields) } # ── 10. Assemble and return result ──────────────────────────────────── result = ReconstructedFrameData( - frames=frames, + frames=mapped_frames, aux_signals=aux_signals, fs=fs, filename=str(path), diff --git a/tests/test_bin_parser.py b/tests/test_bin_parser.py index 1d7d956..4ba099d 100644 --- a/tests/test_bin_parser.py +++ b/tests/test_bin_parser.py @@ -125,7 +125,12 @@ def test_parse_slice_max_frames(tmp_path): # ── float sentinel replacement ──────────────────────────────────────────────── -def test_parse_float_sentinel_replaced_with_nan(tmp_path): +def test_parse_float_sentinel_preserved_in_raw_data(tmp_path): + """Parser returns raw memmap — sentinel values are NOT replaced. + + Sentinel replacement is deferred to the preprocessing layer so that + the memmap is never copied to RAM during parsing (lazy loading). + """ frames = np.zeros(3, dtype=FRAME_BASE_DTYPE) dt_day = 1.0 / (50.0 * 86400.0) frames["ts"] = np.arange(3) * dt_day @@ -134,7 +139,7 @@ def test_parse_float_sentinel_replaced_with_nan(tmp_path): frames.tofile(path) data = DragerBinParser().parse(path) - assert np.isnan(data.pixels[1, 0, 0]) + assert data.pixels[1, 0, 0] == -1000.0 # raw value preserved, not NaN # ── Round-trip value correctness (Tasks 1.5.3 / 1.5.4 / 1.5.5 / 1.5.10) ───── From 7ab5bc6ea507110bb89d0b68682ade1db5c97181 Mon Sep 17 00:00:00 2001 From: Riccardo Date: Thu, 26 Mar 2026 22:25:00 +0000 Subject: [PATCH 2/6] refactor: docstring --- src/fasteit/parsers/draeger/bin/bin_parser.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/fasteit/parsers/draeger/bin/bin_parser.py b/src/fasteit/parsers/draeger/bin/bin_parser.py index d7c23b3..baa49d7 100644 --- a/src/fasteit/parsers/draeger/bin/bin_parser.py +++ b/src/fasteit/parsers/draeger/bin/bin_parser.py @@ -113,9 +113,6 @@ def parse( warnings_list = [] # ── 6. Build aux_signals dict: {signal_name → array shape (N,)} ────── - # Note: sentinel values (e.g. -1000.0, 0xFF7FC99E) are NOT replaced here. - # Sanitization is deferred to the preprocessing layer so that the memmap - # is never copied to RAM during parsing (lazy loading preserved). aux_signals = None if spec.medibus_fields is not None: aux_signals = { From 3e2f1c37c344fb08f8ca4cd07e86040d3b2b8ae9 Mon Sep 17 00:00:00 2001 From: Riccardo Date: Thu, 26 Mar 2026 22:29:49 +0000 Subject: [PATCH 3/6] refactor: remove sentinel replacement from benchmark notebook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit parse_memmap() now returns raw memmap pixels without calling replace_no_data_sentinels — consistent with the parser layer change. Sentinel values are preserved; replacement is preprocessing responsibility. --- notebooks/02_benchmark_parsing.ipynb | 61 +++++++++++++--------------- 1 file changed, 28 insertions(+), 33 deletions(-) diff --git a/notebooks/02_benchmark_parsing.ipynb b/notebooks/02_benchmark_parsing.ipynb index 5fd15b6..302b47d 100644 --- a/notebooks/02_benchmark_parsing.ipynb +++ b/notebooks/02_benchmark_parsing.ipynb @@ -6,7 +6,7 @@ "source": [ "# Benchmark: np.memmap vs struct.unpack\n", "\n", - "fastEIT parses Dräger `.bin` files using `np.memmap`, the OS maps the file\n", + "fastEIT parses Dr\u00e4ger `.bin` files using `np.memmap`, the OS maps the file\n", "directly into virtual memory as a numpy structured array, with no Python loop\n", "and no intermediate copy.\n", "\n", @@ -18,12 +18,12 @@ "every frame. Only the parsing strategy differs.\n", "\n", "**File sizes tested:** 10 MB - 50 MB - 100 MB - 250 MB \n", - "**Frame format:** Dräger BASE (4358 bytes/frame, 1024 float32 pixels per frame)" + "**Frame format:** Dr\u00e4ger BASE (4358 bytes/frame, 1024 float32 pixels per frame)" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -36,13 +36,8 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "# Import the actual dtype and sentinel utilities from fastEIT\n", - "from fasteit.parsers.draeger.bin.draeger_dtypes import FRAME_BASE_DTYPE\n", - "from fasteit.parsers.draeger.bin.bin_utils import (\n", - " replace_no_data_sentinels,\n", - " _BIT_SENTINELS,\n", - " _FLOAT_SENTINELS,\n", - ")" + "# Import the actual dtype from fastEIT\n", + "from fasteit.parsers.draeger.bin.draeger_dtypes import FRAME_BASE_DTYPE" ] }, { @@ -97,16 +92,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generated 10 MB target → 10.00 MB, 2406 frames\n", - "Generated 50 MB target → 50.00 MB, 12030 frames\n", - "Generated 100 MB target → 100.00 MB, 24060 frames\n", - "Generated 250 MB target → 250.00 MB, 60152 frames\n" + "Generated 10 MB target \u2192 10.00 MB, 2406 frames\n", + "Generated 50 MB target \u2192 50.00 MB, 12030 frames\n", + "Generated 100 MB target \u2192 100.00 MB, 24060 frames\n", + "Generated 250 MB target \u2192 250.00 MB, 60152 frames\n" ] } ], "source": [ "def make_synthetic_bin(path: Path, n_frames: int) -> None:\n", - " \"\"\"Write n_frames of random data in Dräger BASE dtype format.\"\"\"\n", + " \"\"\"Write n_frames of random data in Dr\u00e4ger BASE dtype format.\"\"\"\n", " rng = np.random.default_rng(seed=42) # fixed seed = reproducible\n", " frames = np.zeros(n_frames, dtype=FRAME_BASE_DTYPE)\n", " frames[\"ts\"] = rng.uniform(0.5, 0.9, n_frames)\n", @@ -121,7 +116,7 @@ " p = tmpdir / f\"synthetic_{mb}mb.bin\"\n", " make_synthetic_bin(p, n)\n", " bin_files[mb] = p\n", - " print(f\"Generated {mb:>4} MB target → {p.stat().st_size / 1024**2:.2f} MB, {n} frames\")" + " print(f\"Generated {mb:>4} MB target \u2192 {p.stat().st_size / 1024**2:.2f} MB, {n} frames\")" ] }, { @@ -144,16 +139,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def parse_memmap(path: Path) -> np.ndarray:\n", " n_frames = path.stat().st_size // FRAME_SIZE\n", - " # Map file as structured array — zero-copy, OS handles paging\n", + " # Map file as structured array \u2014 zero-copy, OS handles paging\n", + " # Sentinel values are preserved: replacement is deferred to preprocessing layer\n", " mapped = np.memmap(path, dtype=FRAME_BASE_DTYPE, mode=\"r\", shape=(n_frames,))\n", - " pixels = replace_no_data_sentinels(mapped[\"pixels\"], _FLOAT_SENTINELS, _BIT_SENTINELS)\n", - " return pixels\n", + " return mapped[\"pixels\"]\n", "\n", "\n", "_STRUCT_FMT = \" Date: Thu, 26 Mar 2026 22:33:07 +0000 Subject: [PATCH 4/6] docs: update benchmark notebook interpretation for lazy memmap parse_memmap() now returns a lazy view with no pixel array allocated in RAM. Update interpretation to reflect that sentinel replacement is deferred and memmap peak RAM is near zero (only virtual mapping overhead). --- notebooks/02_benchmark_parsing.ipynb | 30 ++++++++++++++++------------ 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/notebooks/02_benchmark_parsing.ipynb b/notebooks/02_benchmark_parsing.ipynb index 302b47d..656535b 100644 --- a/notebooks/02_benchmark_parsing.ipynb +++ b/notebooks/02_benchmark_parsing.ipynb @@ -326,19 +326,23 @@ "\n", "memmap is faster and uses less RAM across all file sizes tested.\n", "\n", - "At **small files** (10\u201350 MB), the OS page cache likely holds the file after\n", - "generation, so memmap reads are served from memory without disk I/O.\n", - "struct.unpack is bottlenecked by Python overhead: one function call and one\n", - "tuple allocation per frame, regardless of file size.\n", - "\n", - "At **large files** (100\u2013250 MB), both approaches become **I/O-bound**, reading\n", - "from disk dominates the total time. struct's Python overhead stays constant in\n", - "absolute terms but shrinks as a fraction of the total, so the speedup ratio\n", - "drops (from ~21\u00d7 at 50 MB to ~9\u00d7 at 250 MB). Both are limited by the same disk bandwidth floor.\n", - "\n", - "struct peak RAM grows with file size because it loads the entire file into a\n", - "`bytes` buffer before parsing. memmap peak RAM grows only with the pixel output\n", - "array. Roughly 60% of struct's peak at equivalent file size." + "**Why memmap is fast:** `np.memmap` sets up a virtual address space mapping \u2014\n", + "the OS loads file pages on demand. `parse_memmap()` returns a lazy view of\n", + "the pixel field: no data is actually read from disk until the caller accesses\n", + "the array. Sentinel replacement is deferred to the preprocessing layer.\n", + "\n", + "**Why struct.unpack is slow:** `path.read_bytes()` loads the entire file into\n", + "a Python `bytes` buffer in RAM before any parsing begins. Every frame then\n", + "requires one `struct.unpack_from` call and one tuple allocation \u2014 pure Python\n", + "overhead that scales linearly with frame count.\n", + "\n", + "At **large files** (100\u2013250 MB) both become I/O-bound; struct's Python overhead\n", + "shrinks as a fraction of total time, so the speedup ratio drops (~21\u00d7 at 50 MB\n", + "\u2192 ~9\u00d7 at 250 MB).\n", + "\n", + "struct peak RAM grows linearly: one full `bytes` buffer + one pixel array.\n", + "memmap peak RAM is near zero: only the virtual mapping is set up, no pixel\n", + "array is allocated in RAM." ] } ], From 3db171d022b38803768e568d0decf3187a4c2610 Mon Sep 17 00:00:00 2001 From: Riccardo Date: Thu, 26 Mar 2026 22:44:38 +0000 Subject: [PATCH 5/6] docs: update benchmark results and fix grammar in interpretation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Re-run after removing sentinel replacement from parse_memmap(): - memmap time: 0.000 s at all sizes (pure mapping setup, no pixel reads) - memmap peak RAM: 0.0 MB (no pixel array allocated — lazy view only) - struct loop unchanged as expected Fix grammar in interpretation cell. Remove redundant inline comment in test_bin_parser.py. --- notebooks/02_benchmark_parsing.ipynb | 56 +++++++++------------------- tests/test_bin_parser.py | 4 +- 2 files changed, 18 insertions(+), 42 deletions(-) diff --git a/notebooks/02_benchmark_parsing.ipynb b/notebooks/02_benchmark_parsing.ipynb index 656535b..039b983 100644 --- a/notebooks/02_benchmark_parsing.ipynb +++ b/notebooks/02_benchmark_parsing.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -139,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -190,27 +190,27 @@ "text": [ "\n", "\u2500\u2500 10 MB (2406 frames) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " memmap: 0.004 s\n", - " struct loop: 0.073 s\n", - " RAM memmap: 14.1 MB\n", + " memmap: 0.000 s\n", + " struct loop: 0.071 s\n", + " RAM memmap: 0.0 MB\n", " RAM struct: 19.5 MB\n", "\n", "\u2500\u2500 50 MB (12030 frames) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " memmap: 0.018 s\n", - " struct loop: 0.369 s\n", - " RAM memmap: 70.5 MB\n", + " memmap: 0.000 s\n", + " struct loop: 0.345 s\n", + " RAM memmap: 0.0 MB\n", " RAM struct: 97.1 MB\n", "\n", "\u2500\u2500 100 MB (24060 frames) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " memmap: 0.037 s\n", - " struct loop: 0.711 s\n", - " RAM memmap: 141.0 MB\n", + " memmap: 0.000 s\n", + " struct loop: 0.770 s\n", + " RAM memmap: 0.0 MB\n", " RAM struct: 194.0 MB\n", "\n", "\u2500\u2500 250 MB (60152 frames) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", - " memmap: 0.094 s\n", - " struct loop: 1.727 s\n", - " RAM memmap: 352.5 MB\n", + " memmap: 0.000 s\n", + " struct loop: 1.708 s\n", + " RAM memmap: 0.0 MB\n", " RAM struct: 485.0 MB\n", "\n", "Done.\n" @@ -269,12 +269,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -321,29 +321,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## Interpretation\n", - "\n", - "memmap is faster and uses less RAM across all file sizes tested.\n", - "\n", - "**Why memmap is fast:** `np.memmap` sets up a virtual address space mapping \u2014\n", - "the OS loads file pages on demand. `parse_memmap()` returns a lazy view of\n", - "the pixel field: no data is actually read from disk until the caller accesses\n", - "the array. Sentinel replacement is deferred to the preprocessing layer.\n", - "\n", - "**Why struct.unpack is slow:** `path.read_bytes()` loads the entire file into\n", - "a Python `bytes` buffer in RAM before any parsing begins. Every frame then\n", - "requires one `struct.unpack_from` call and one tuple allocation \u2014 pure Python\n", - "overhead that scales linearly with frame count.\n", - "\n", - "At **large files** (100\u2013250 MB) both become I/O-bound; struct's Python overhead\n", - "shrinks as a fraction of total time, so the speedup ratio drops (~21\u00d7 at 50 MB\n", - "\u2192 ~9\u00d7 at 250 MB).\n", - "\n", - "struct peak RAM grows linearly: one full `bytes` buffer + one pixel array.\n", - "memmap peak RAM is near zero: only the virtual mapping is set up, no pixel\n", - "array is allocated in RAM." - ] + "source": "## Interpretation\n\nmemmap is faster and uses less RAM across all file sizes tested.\n\n**Why memmap is fast:** `np.memmap` sets up a virtual address space mapping \u2014 the OS loads file pages on demand. `parse_memmap()` returns a lazy view of the pixel field: no data is actually read from disk until accessed; the mapping is read-only.\n\n**Why struct.unpack is slower:** `path.read_bytes()` loads the entire file into a Python `bytes` buffer in RAM before any parsing begins. Every frame then requires one `struct.unpack_from` call and one tuple allocation.\n\nstruct peak RAM grows linearly: one full `bytes` buffer + one pixel array.\nmemmap peak RAM is near zero: only the virtual mapping is set up, no pixel array is allocated in RAM.\n\nThis could be useful to separate completely the parsing layer and the preprocessing layer. The computational cost stays entirely in the preprocessing layer, avoiding extra overhead when parsing more than one file. You will pay the computational cost only on the file you intend to work on, and only when you start working on it." } ], "metadata": { diff --git a/tests/test_bin_parser.py b/tests/test_bin_parser.py index 4ba099d..246ff84 100644 --- a/tests/test_bin_parser.py +++ b/tests/test_bin_parser.py @@ -139,12 +139,10 @@ def test_parse_float_sentinel_preserved_in_raw_data(tmp_path): frames.tofile(path) data = DragerBinParser().parse(path) - assert data.pixels[1, 0, 0] == -1000.0 # raw value preserved, not NaN + assert data.pixels[1, 0, 0] == -1000.0 # ── Round-trip value correctness (Tasks 1.5.3 / 1.5.4 / 1.5.5 / 1.5.10) ───── -# Uses the shared bin_3frames fixture from conftest.py. -# Frame i has all pixels = float(i+1), timestamps at 50 Hz fraction-of-day. _DT_DAY = 1.0 / (50.0 * 86400.0) From 777cd09b8db28e1a37b54d2f0daf04583f47c6b6 Mon Sep 17 00:00:00 2001 From: Riccardo Date: Thu, 26 Mar 2026 23:02:15 +0000 Subject: [PATCH 6/6] style: remove trailing whitespace in test_bin_parser.py --- tests/test_bin_parser.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_bin_parser.py b/tests/test_bin_parser.py index 246ff84..dfb8a88 100644 --- a/tests/test_bin_parser.py +++ b/tests/test_bin_parser.py @@ -139,7 +139,7 @@ def test_parse_float_sentinel_preserved_in_raw_data(tmp_path): frames.tofile(path) data = DragerBinParser().parse(path) - assert data.pixels[1, 0, 0] == -1000.0 + assert data.pixels[1, 0, 0] == -1000.0 # ── Round-trip value correctness (Tasks 1.5.3 / 1.5.4 / 1.5.5 / 1.5.10) ─────