@@ -1028,3 +1146,37 @@
+
+
+
+
+ Report a Bug
+
+
+
+
+
+ To help us fix the issue, please send an email to:
+
+ julian.sierrag@icloud.com
+
+
+ Subject: JuliaMSI Bug
+
+
+
+
+
+ Please include:
+
+ - The full error message.
+ - Steps to reproduce the crash.
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/julia_imzML_visual.jl b/julia_imzML_visual.jl
index 37325e4..da11bd3 100644
--- a/julia_imzML_visual.jl
+++ b/julia_imzML_visual.jl
@@ -1,6 +1,5 @@
# julia_imzML_visual.jl
-const REGISTRY_LOCK = ReentrantLock()
"""
increment_image(current_image, image_list)
diff --git a/mask.jl b/mask.jl
index 608269b..8b0df75 100644
--- a/mask.jl
+++ b/mask.jl
@@ -9,7 +9,7 @@ using Statistics, NaturalSort, LinearAlgebra, StipplePlotly
using Base.Filesystem: mv
using MSI_src
-using .MSI_src: MSIData, process_image_pipeline
+using .MSI_src: MSIData, process_image_pipeline, REGISTRY_LOCK
# Plot Handling
include("./julia_imzML_visual.jl")
@@ -799,8 +799,10 @@ end
end
# Save the updated registry
- open(reg_path, "w") do f
- JSON.print(f, registry, 4)
+ lock(REGISTRY_LOCK) do
+ open(reg_path, "w") do f
+ JSON.print(f, registry, 4)
+ end
end
@info "Registry updated with mask: $(final_mask_name)"
@@ -874,8 +876,10 @@ end
if !isempty(new_folders) || !isempty(removed_folders)
println("Registry changed, saving...")
- open(reg_path, "w") do f
- JSON.print(f, registry, 4)
+ lock(REGISTRY_LOCK) do
+ open(reg_path, "w") do f
+ JSON.print(f, registry, 4)
+ end
end
end
diff --git a/src/Common.jl b/src/Common.jl
index 850a466..b74d969 100644
--- a/src/Common.jl
+++ b/src/Common.jl
@@ -82,30 +82,35 @@ A dramatically simplified buffer pool that avoids complex locking.
mutable struct SimpleBufferPool
buffers::Dict{Int, Vector{Vector{UInt8}}}
max_pool_size::Int
+ lock::ReentrantLock # Add lock for thread safety
end
-SimpleBufferPool() = SimpleBufferPool(Dict{Int, Vector{Vector{UInt8}}}(), 50)
+SimpleBufferPool() = SimpleBufferPool(Dict{Int, Vector{Vector{UInt8}}}(), 50, ReentrantLock())
function get_buffer!(pool::SimpleBufferPool, size::Int)::Vector{UInt8}
- # Check for existing buffers of exact size first
- if haskey(pool.buffers, size) && !isempty(pool.buffers[size])
- return pop!(pool.buffers[size])
+ lock(pool.lock) do
+ # Check for existing buffers of exact size first
+ if haskey(pool.buffers, size) && !isempty(pool.buffers[size])
+ return pop!(pool.buffers[size])
+ end
end
- # No suitable buffer found, allocate new one
+ # No suitable buffer found, allocate new one (outside lock to reduce contention)
return Vector{UInt8}(undef, size)
end
function release_buffer!(pool::SimpleBufferPool, buffer::Vector{UInt8})
size = length(buffer)
- if !haskey(pool.buffers, size)
- pool.buffers[size] = Vector{Vector{UInt8}}()
- end
-
- # Limit pool size to prevent memory bloat
- if length(pool.buffers[size]) < pool.max_pool_size
- push!(pool.buffers[size], buffer)
+ lock(pool.lock) do
+ if !haskey(pool.buffers, size)
+ pool.buffers[size] = Vector{Vector{UInt8}}()
+ end
+
+ # Limit pool size to prevent memory bloat
+ if length(pool.buffers[size]) < pool.max_pool_size
+ push!(pool.buffers[size], buffer)
+ end
end
# If pool is full, let buffer get GC'd
end
diff --git a/src/MSIData.jl b/src/MSIData.jl
index 439ebd6..3b4e553 100644
--- a/src/MSIData.jl
+++ b/src/MSIData.jl
@@ -35,7 +35,12 @@ Atomically seeks to a position and reads data into an array. This is the thread-
way to read from a specific offset in the file.
"""
function read_at!(tsfh::ThreadSafeFileHandle, a::AbstractArray, pos::Integer)
+ if pos < 0
+ throw(ArgumentError("Invalid seek position: $pos"))
+ end
lock(tsfh.lock) do
+ # Also check against file size if possible, though filesize() might be expensive to call repeatedly
+ # Let's rely on seek throwing if it goes way out of bounds, but catch the negative case which is definitely an error.
seek(tsfh.handle, pos)
read!(tsfh.handle, a)
end
@@ -510,6 +515,19 @@ function read_spectrum_from_disk(source::ImzMLSource, meta::SpectrumMetadata)
mz = Array{source.mz_format}(undef, meta.mz_asset.encoded_length)
intensity = Array{source.intensity_format}(undef, meta.int_asset.encoded_length)
+ # Validate offsets before reading
+ file_size = filesize(source.ibd_handle)
+
+ mz_end = meta.mz_asset.offset + sizeof(source.mz_format) * meta.mz_asset.encoded_length
+ if meta.mz_asset.offset < 0 || mz_end > file_size
+ throw(FileFormatError("Invalid m/z data offset/length for spectrum $(meta.id): offset=$(meta.mz_asset.offset), end=$mz_end, file_size=$file_size"))
+ end
+
+ int_end = meta.int_asset.offset + sizeof(source.intensity_format) * meta.int_asset.encoded_length
+ if meta.int_asset.offset < 0 || int_end > file_size
+ throw(FileFormatError("Invalid intensity data offset/length for spectrum $(meta.id): offset=$(meta.int_asset.offset), end=$int_end, file_size=$file_size"))
+ end
+
# Use the new atomic read_at! method for thread-safety
read_at!(source.ibd_handle, mz, meta.mz_asset.offset)
read_at!(source.ibd_handle, intensity, meta.int_asset.offset)
diff --git a/src/MSI_src.jl b/src/MSI_src.jl
index 3dd7243..4ab390f 100644
--- a/src/MSI_src.jl
+++ b/src/MSI_src.jl
@@ -19,7 +19,11 @@ export OpenMSIData,
get_global_mz_range,
MSIData,
_iterate_spectra_fast,
- validate_spectrum
+ validate_spectrum,
+ REGISTRY_LOCK
+
+# Define shared registry lock
+const REGISTRY_LOCK = ReentrantLock()
# Export the public preprocessing & precalculations API
export run_preprocessing_analysis,
diff --git a/src/Precalculations.jl b/src/Precalculations.jl
index 70e28f7..a99b74f 100644
--- a/src/Precalculations.jl
+++ b/src/Precalculations.jl
@@ -1,4 +1,5 @@
using StatsBase # For mean, std, median, quantile, mad
+using Base.Threads # For atomic counters and locking
# =============================================================================
# 7) Spatial & Advanced Processing (Stubs & New Functions)
@@ -80,11 +81,12 @@ function analyze_mass_accuracy(
println("Analyzing mass accuracy for $(length(spectrum_indices)) spectra...")
all_ppm_errors = Float64[]
- total_matched_peaks = 0
- total_spectra_processed = 0
+ total_matched_peaks = Atomic{Int}(0)
+ total_spectra_processed = Atomic{Int}(0)
+ results_lock = ReentrantLock()
_iterate_spectra_fast(msi_data, spectrum_indices) do idx, mz, intensity
- total_spectra_processed += 1
+ atomic_add!(total_spectra_processed, 1)
if !validate_spectrum(mz, intensity)
@warn "Spectrum $idx is invalid, skipping mass accuracy analysis for it."
return
@@ -106,8 +108,10 @@ function analyze_mass_accuracy(
end
if best_matched_peak_mz !== nothing
- push!(all_ppm_errors, min_ppm_error)
- total_matched_peaks += 1
+ lock(results_lock) do
+ push!(all_ppm_errors, min_ppm_error)
+ end
+ atomic_add!(total_matched_peaks, 1)
end
end
end
@@ -140,8 +144,8 @@ function analyze_mass_accuracy(
std_ppm_error = std_err,
min_ppm_error = min_err,
max_ppm_error = max_err,
- total_matched_peaks = total_matched_peaks,
- total_spectra_analyzed = total_spectra_processed,
+ total_matched_peaks = total_matched_peaks[],
+ total_spectra_analyzed = total_spectra_processed[],
ppm_error_distribution = all_ppm_errors
)
end
@@ -318,21 +322,29 @@ function analyze_instrument_characteristics(msi_data::MSIData; sample_indices::A
return results
end
+ results_lock = ReentrantLock()
+
_iterate_spectra_fast(msi_data, sample_indices) do idx, mz, intensity
# Record spectrum mode
- push!(spectrum_modes, msi_data.spectra_metadata[idx].mode)
+ lock(results_lock) do
+ push!(spectrum_modes, msi_data.spectra_metadata[idx].mode)
+ end
# Calculate m/z step statistics (for profile data)
if length(mz) > 1 && msi_data.spectra_metadata[idx].mode == PROFILE
steps = diff(mz)
if !isempty(steps)
- push!(mz_step_sizes, mean(steps))
+ lock(results_lock) do
+ push!(mz_step_sizes, mean(steps))
+ end
end
end
# Record intensity range
if !isempty(intensity)
- push!(intensity_ranges, (minimum(intensity), maximum(intensity)))
+ lock(results_lock) do
+ push!(intensity_ranges, (minimum(intensity), maximum(intensity)))
+ end
end
end
@@ -442,11 +454,15 @@ function analyze_signal_quality(msi_data::MSIData; sample_indices::AbstractVecto
return results
end
+ results_lock = ReentrantLock()
+
_iterate_spectra_fast(msi_data, sample_indices) do idx, mz, intensity
if !isempty(intensity)
# Noise estimation using MAD
noise = mad(intensity, normalize=true)
- push!(noise_levels, noise)
+ lock(results_lock) do
+ push!(noise_levels, noise)
+ end
# FIX: More robust SNR calculation
valid_intensity = intensity[intensity .> 0] # Remove zeros
@@ -458,12 +474,16 @@ function analyze_signal_quality(msi_data::MSIData; sample_indices::AbstractVecto
if noise_robust > 0 && isfinite(signal_estimate)
snr_val = signal_estimate / noise_robust
# Cap unrealistic SNR values
- push!(snr_distribution, min(snr_val, 1e6))
+ lock(results_lock) do
+ push!(snr_distribution, min(snr_val, 1e6))
+ end
end
end
# Total ion count
- push!(tic_values, sum(intensity))
+ lock(results_lock) do
+ push!(tic_values, sum(intensity))
+ end
end
end
@@ -651,20 +671,23 @@ function analyze_peak_characteristics(msi_data::MSIData, instrument_analysis::Di
peak_counts = Int[]
fwhm_values = Float64[]
- spectra_analyzed = 0
- peaks_analyzed = 0
+ spectra_analyzed = Atomic{Int}(0)
+ peaks_analyzed = Atomic{Int}(0)
+ results_lock = ReentrantLock()
_iterate_spectra_fast(msi_data, spectrum_indices) do idx, mz, intensity
if length(mz) < 10 # Skip spectra with too few points
return
end
- spectra_analyzed += 1
+ atomic_add!(spectra_analyzed, 1)
meta = msi_data.spectra_metadata[idx]
# Detect peaks with lower SNR threshold to find more peaks
peaks = detect_peaks_profile_core(mz, intensity; snr_threshold=2.0)
- push!(peak_counts, length(peaks))
+ lock(results_lock) do
+ push!(peak_counts, length(peaks))
+ end
if !isempty(peaks)
# Analyze the strongest 3 peaks per spectrum
@@ -679,15 +702,17 @@ function analyze_peak_characteristics(msi_data::MSIData, instrument_analysis::Di
if !isnan(fwhm_delta_m) && fwhm_delta_m > 0.001 && fwhm_delta_m < 0.5 # Reasonable range in Da
fwhm_ppm = 1e6 * fwhm_delta_m / peak.mz
if 5.0 < fwhm_ppm < 500.0 # Reasonable ppm range
- push!(peak_widths_ppm, fwhm_ppm)
- push!(fwhm_values, fwhm_delta_m)
+ lock(results_lock) do
+ push!(peak_widths_ppm, fwhm_ppm)
+ push!(fwhm_values, fwhm_delta_m)
+
+ r2 = _fit_gaussian_and_r2(mz, intensity, peak_idx, 5)
+ push!(r_squared_values, r2)
+ end
+ atomic_add!(peaks_analyzed, 1)
- r2 = _fit_gaussian_and_r2(mz, intensity, peak_idx, 5)
- push!(r_squared_values, r2)
- peaks_analyzed += 1
-
- if peaks_analyzed <= 3
- println("DEBUG: Peak at m/z $(peak.mz), FWHM = $(fwhm_ppm) ppm, R² = $r2")
+ if peaks_analyzed[] <= 3
+ println("DEBUG: Peak at m/z $(peak.mz), FWHM = $(fwhm_ppm) ppm, R² = $(r_squared_values[end])")
end
end
end
@@ -698,7 +723,7 @@ function analyze_peak_characteristics(msi_data::MSIData, instrument_analysis::Di
end
end
- println("DEBUG: Analyzed $peaks_analyzed peaks from $spectra_analyzed spectra")
+ println("DEBUG: Analyzed $(peaks_analyzed[]) peaks from $(spectra_analyzed[]) spectra")
if !isempty(peak_widths_ppm)
results[:mean_fwhm_ppm] = mean(peak_widths_ppm)
@@ -727,9 +752,13 @@ function analyze_peak_characteristics(msi_data::MSIData, instrument_analysis::Di
peak_counts = Int[]
+ results_lock = ReentrantLock()
+
_iterate_spectra_fast(msi_data, spectrum_indices) do idx, mz, intensity
if !isempty(mz)
- push!(peak_counts, length(mz))
+ lock(results_lock) do
+ push!(peak_counts, length(mz))
+ end
end
end
diff --git a/src/PreprocessingPipeline.jl b/src/PreprocessingPipeline.jl
index 5118dad..c990156 100644
--- a/src/PreprocessingPipeline.jl
+++ b/src/PreprocessingPipeline.jl
@@ -33,7 +33,15 @@ function apply_baseline_correction(spectra::Vector{MutableSpectrum}, params::Dic
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
+ original_length = length(s.intensity)
baseline = apply_baseline_correction_core(s.intensity; method=method, iterations=iterations, window=window)
+
+ # CRITICAL: Ensure baseline has the same length as intensity
+ if length(baseline) != original_length
+ @warn "Baseline correction: length mismatch for spectrum $(s.id). baseline=$(length(baseline)), intensity=$original_length. Skipping this spectrum."
+ continue
+ end
+
s.intensity = max.(0.0, s.intensity .- baseline)
end
end
@@ -53,7 +61,16 @@ function apply_intensity_transformation(spectra::Vector{MutableSpectrum}, params
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
- s.intensity = transform_intensity_core(s.intensity; method=method)
+ original_length = length(s.intensity)
+ transformed = transform_intensity_core(s.intensity; method=method)
+
+ # CRITICAL: Ensure transformation preserves array length
+ if length(transformed) != original_length
+ @warn "Intensity transformation: length mismatch for spectrum $(s.id). transformed=$(length(transformed)), original=$original_length. Skipping this spectrum."
+ continue
+ end
+
+ s.intensity = transformed
end
end
end
@@ -76,8 +93,16 @@ function apply_smoothing(spectra::Vector{MutableSpectrum}, params::Dict)
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
- smoothed_intensity = max.(0.0, smooth_spectrum_core(s.intensity; method=method, window=window, order=order))
- s.intensity = smoothed_intensity
+ original_length = length(s.intensity)
+ smoothed_intensity = smooth_spectrum_core(s.intensity; method=method, window=window, order=order)
+
+ # CRITICAL: Ensure smoothing preserves array length
+ if length(smoothed_intensity) != original_length
+ @warn "Smoothing: length mismatch for spectrum $(s.id). smoothed=$(length(smoothed_intensity)), original=$original_length, method=$method, window=$window. Skipping this spectrum."
+ continue
+ end
+
+ s.intensity = max.(0.0, smoothed_intensity)
end
end
end
@@ -104,6 +129,7 @@ function apply_peak_picking(spectra::Vector{MutableSpectrum}, params::Dict)
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
+ # old_len = length(s.peaks)
if method == :profile
s.peaks = detect_peaks_profile_core(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window, min_peak_prominence=min_peak_prominence, merge_peaks_tolerance=merge_peaks_tolerance)
elseif method == :wavelet
@@ -113,6 +139,7 @@ function apply_peak_picking(spectra::Vector{MutableSpectrum}, params::Dict)
else
s.peaks = detect_peaks_profile_core(s.mz, s.intensity; snr_threshold=snr_threshold, half_window=half_window)
end
+ # @info "Spectrum $(s.id): detected $(length(s.peaks)) peaks"
else
s.peaks = []
end
@@ -182,12 +209,21 @@ function apply_calibration(spectra::Vector{MutableSpectrum}, params::Dict, refer
Threads.@threads for i in 1:length(spectra)
s = spectra[i]
if validate_spectrum(s.mz, s.intensity)
+ original_length = length(s.mz)
matched_peaks = find_calibration_peaks_core(s.mz, s.intensity, reference_masses; ppm_tolerance=ppm_tolerance)
if length(matched_peaks) >= 2
measured = sort(collect(values(matched_peaks)))
theoretical = sort(collect(keys(matched_peaks)))
itp = linear_interpolation(measured, theoretical, extrapolation_bc=Line())
- s.mz = itp(s.mz) # Modify mz-axis in-place
+ new_mz = itp(s.mz)
+
+ # CRITICAL: Ensure m/z axis preserves array length
+ if length(new_mz) != original_length
+ @warn "Calibration: length mismatch for spectrum $(s.id). new_mz=$(length(new_mz)), original=$original_length. Skipping this spectrum."
+ continue
+ end
+
+ s.mz = new_mz # Modify mz-axis in-place
else
@warn "Spectrum $(s.id): insufficient reference peaks ($(length(matched_peaks)) found), skipping calibration."
end
@@ -233,7 +269,16 @@ function apply_peak_alignment(spectra::Vector{MutableSpectrum}, params::Dict)
current_peaks_mz = [p.mz for p in s.peaks]
alignment_func = align_peaks_lowess_core(ref_peaks_mz, current_peaks_mz; method=method, tolerance=tolerance, tolerance_unit=tolerance_unit)
- s.mz = alignment_func.(s.mz) # Update m/z axis
+ original_length = length(s.mz)
+ new_mz = alignment_func.(s.mz)
+
+ # CRITICAL: Ensure alignment preserves array length
+ if length(new_mz) != original_length
+ @warn "Peak alignment: m/z length mismatch for spectrum $(s.id). new_mz=$(length(new_mz)), original=$original_length. Skipping this spectrum."
+ continue
+ end
+
+ s.mz = new_mz # Update m/z axis
# Update peak m/z values
for i in 1:length(s.peaks)
@@ -258,7 +303,16 @@ function apply_normalization(spectra::Vector{MutableSpectrum}, params::Dict)
Threads.@threads for s in spectra
if validate_spectrum(s.mz, s.intensity)
- s.intensity = apply_normalization_core(s.intensity; method=method)
+ original_length = length(s.intensity)
+ normalized = apply_normalization_core(s.intensity; method=method)
+
+ # CRITICAL: Ensure normalization preserves array length
+ if length(normalized) != original_length
+ @warn "Normalization: length mismatch for spectrum $(s.id). normalized=$(length(normalized)), original=$original_length. Skipping this spectrum."
+ continue
+ end
+
+ s.intensity = normalized
end
end
end
diff --git a/start_MSI_GUI.jl b/start_MSI_GUI.jl
index ffc8250..1e1c14a 100644
--- a/start_MSI_GUI.jl
+++ b/start_MSI_GUI.jl
@@ -6,17 +6,14 @@ ENV["GENIE_ENV"] = "dev"
manifest_path = joinpath(@__DIR__, "Manifest.toml")
-# Only instantiate in development mode
-if get(ENV, "GENIE_ENV", "dev") != "prod" || !isfile(manifest_path)
- @info "Development environment detected. Instantiating packages..."
-
- if !isfile(manifest_path)
- @info "Manifest.toml not found. Generating it based on Project.toml..."
- end
-
+# Selective instantiation for faster startup
+if get(ENV, "GENIE_ENV", "dev") != "prod" && !isfile(manifest_path)
+ @info "Development environment detected and Manifest.toml missing. Instantiating packages..."
Pkg.resolve()
Pkg.instantiate()
Pkg.gc()
+elseif get(ENV, "GENIE_ENV", "dev") != "prod"
+ @info "Manifest.toml found. Skipping Pkg.instantiate() for faster boot. Delete Manifest.toml if you need to re-instantiate."
end
using Genie
diff --git a/test/test_buffer_pool_concurrency.jl b/test/test_buffer_pool_concurrency.jl
new file mode 100644
index 0000000..3896b2e
--- /dev/null
+++ b/test/test_buffer_pool_concurrency.jl
@@ -0,0 +1,32 @@
+using MSI_src
+using Test
+using Base.Threads
+
+@testset "SimpleBufferPool Concurrency Stress Test" begin
+ pool = MSI_src.SimpleBufferPool()
+ n_threads = Threads.nthreads()
+ n_iterations = 1000
+ buffer_size = 1024
+
+ println("Running buffer pool stress test with $n_threads threads...")
+
+ # Parallel stress test
+ Threads.@threads for i in 1:(n_threads * n_iterations)
+ # get_buffer! and release_buffer! are now thread-safe
+ buf = MSI_src.get_buffer!(pool, buffer_size)
+
+ # Simulate some work
+ fill!(buf, UInt8(i % 256))
+
+ MSI_src.release_buffer!(pool, buf)
+ end
+
+ # After stress test, the dictionary should be coherent
+ sizes = collect(keys(pool.buffers))
+ if !isempty(sizes)
+ @test buffer_size ∈ sizes
+ @test length(pool.buffers[buffer_size]) <= pool.max_pool_size
+ end
+
+ println("Buffer pool stress test PASSED.")
+end
diff --git a/test/test_pipeline_concurrency.jl b/test/test_pipeline_concurrency.jl
new file mode 100644
index 0000000..2e5f5c6
--- /dev/null
+++ b/test/test_pipeline_concurrency.jl
@@ -0,0 +1,146 @@
+
+using Pkg
+Pkg.activate(joinpath(@__DIR__, ".."))
+using MSI_src
+using Test
+using Base.Threads
+
+# --- Test Configuration ---
+const TEST_FILE = "/home/pixel/Documents/Cinvestav_2025/Analisis/Stomach/Stomach_DHB_uncompressed.imzML"
+
+println("Starting concurrency test with file: $TEST_FILE")
+
+if !isfile(TEST_FILE)
+ error("Test file not found: $TEST_FILE")
+end
+
+# --- Simulation of the Concurrency Issue ---
+
+# Global "UI State" variable simulates the app's msi_data
+global_msi_data = nothing
+const GLOBAL_LOCK = ReentrantLock()
+
+function ui_load_file(path)
+ global global_msi_data
+ lock(GLOBAL_LOCK) do
+ if global_msi_data !== nothing
+ close(global_msi_data)
+ end
+ println("UI: Loading file...")
+ global_msi_data = OpenMSIData(path)
+ println("UI: File loaded.")
+ end
+end
+
+function ui_close_file()
+ global global_msi_data
+ lock(GLOBAL_LOCK) do
+ if global_msi_data !== nothing
+ println("UI: Closing file...")
+ close(global_msi_data)
+ global_msi_data = nothing
+ println("UI: File closed.")
+ end
+ end
+end
+
+# Mock pipeline function that mimics `run_full_pipeline` in app.jl
+# Crucially, it uses its own local `pipeline_msi_data` as per the fix
+function run_mock_pipeline_isolated(path)
+ println("Pipeline: Starting isolated pipeline...")
+
+ # 1. Open ISOLATED instance
+ pipeline_msi_data = OpenMSIData(path)
+ println("Pipeline: Opened isolated MSIData instance.")
+
+ try
+ # 2. Simulate reading spectra
+ indices = 1:min(100, length(pipeline_msi_data.spectra_metadata)) # Read first 100 spectra
+
+ # Artificial delay to allow "user" interaction
+ sleep(0.5)
+
+ println("Pipeline: Reading spectra...")
+ Threads.@threads for i in indices
+ # Use local instance
+ mz, int = GetSpectrum(pipeline_msi_data, i)
+ # Simulate processing work
+ sum(int)
+ end
+ println("Pipeline: Finished reading spectra successfully.")
+ return true
+ catch e
+ println("Pipeline: CRASHED with error: $e")
+ return false
+ finally
+ close(pipeline_msi_data)
+ println("Pipeline: Closed isolated MSIData instance.")
+ end
+end
+
+# Mock pipeline that uses GLOBAL instance (The BUGGY version)
+function run_mock_pipeline_buggy()
+ println("Buggy Pipeline: Starting...")
+ # Uses global_msi_data directly
+
+ try
+ global global_msi_data
+ if global_msi_data === nothing
+ println("Buggy Pipeline: No data loaded!")
+ return false
+ end
+
+ local_ref = global_msi_data # Still points to same object
+
+ indices = 1:min(100, length(local_ref.spectra_metadata))
+
+ sleep(0.5)
+
+ println("Buggy Pipeline: Reading spectra from shared object...")
+ Threads.@threads for i in indices
+ # This will fail if ui_close_file() happens concurrently
+ mz, int = GetSpectrum(local_ref, i)
+ sum(int)
+ end
+ println("Buggy Pipeline: Success (Unexpected if concurrency worked)")
+ return true
+ catch e
+ println("Buggy Pipeline: CRASHED as expected: $e")
+ return false
+ end
+end
+
+
+# --- execute checks ---
+
+@testset "Concurrency Crash Fix Verification" begin
+
+ # 1. Setup: Load file initially
+ ui_load_file(TEST_FILE)
+
+ # 2. Test the FIX: Isolated Pipeline
+ println("\n--- Testing Fixed (Isolated) Pipeline ---")
+
+ t_pipeline = Threads.@spawn run_mock_pipeline_isolated(TEST_FILE)
+
+ # Simulate user closing/reloading file while pipeline runs
+ sleep(0.2)
+ ui_close_file()
+
+ # Wait for pipeline
+ success = fetch(t_pipeline)
+ @test success == true
+ println("Fixed pipeline result: ", success ? "PASSED" : "FAILED")
+
+
+ # 3. Test the BUG: Global Pipeline (Optional, to prove it crashes without fix)
+ # Uncomment to verify the bug exists if needed, but we assume it does based on user report.
+ # println("\n--- Testing Buggy (Shared) Pipeline ---")
+ # ui_load_file(TEST_FILE)
+ # t_buggy = Threads.@spawn run_mock_pipeline_buggy()
+ # sleep(0.2)
+ # ui_close_file()
+ # buggy_success = fetch(t_buggy)
+ # println("Buggy pipeline result: ", buggy_success ? "PASSED (No crash?)" : "FAILED (Crashed as expected)")
+
+end