seqtable 0.2.0

High-performance FASTQ sequence counter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#![cfg(feature = "cli")]
//! Heap profiling with dhat.
//!
//! Run:   cargo test --test heap_profile --profile profiling -- --nocapture --test-threads=1
//! View:  open dhat-heap.json at https://nnethercote.github.io/dh_view/dh_view.html
//!
//! Requires bench fixtures:
//!   cargo run --example generate_fixtures --release -- --size bench

#[global_allocator]
static ALLOC: dhat::Alloc = dhat::Alloc;

use seqtable::output::{save_csv, save_parquet};
use seqtable::{count_sequences, prepare_records};
use std::path::Path;

const FIXTURE_DIR: &str = "tests/fixtures";

fn fixture_path(name: &str) -> Option<std::path::PathBuf> {
    let p = Path::new(FIXTURE_DIR).join(name);
    p.exists().then_some(p)
}

/// Full pipeline profile — generates dhat-heap.json for viewer.
/// Run manually: cargo test --test heap_profile profile_full_pipeline -- --ignored --test-threads=1
#[test]
#[ignore]
fn profile_full_pipeline() {
    let Some(path) = fixture_path("bn_short_mid_10000.fastq") else {
        eprintln!("skip: run cargo run --example generate_fixtures --release -- --size bench");
        return;
    };

    let _prof = dhat::Profiler::new_heap();

    // Phase 1: Count
    let (counts, total) = count_sequences(&path, 0, false).unwrap();

    // Phase 2: Prepare
    let records = prepare_records(counts);

    // Phase 3: Output
    let tmp = tempfile::NamedTempFile::with_suffix(".csv").unwrap();
    save_csv(&records, tmp.path(), b',', total, false).unwrap();

    // Profiler drops here, writes dhat-heap.json
}

/// Per-phase stats via testing mode
#[test]
fn profile_per_phase() {
    let fixtures = [
        ("short_low_5%", "bn_short_low_10000.fastq"),
        ("short_mid_50%", "bn_short_mid_10000.fastq"),
        ("short_high_90%", "bn_short_high_10000.fastq"),
        ("amp_low_5%", "bn_amp_low_10000.fastq"),
        ("amp_mid_50%", "bn_amp_mid_10000.fastq"),
        ("amp_high_90%", "bn_amp_high_10000.fastq"),
    ];

    for (label, file) in fixtures {
        let Some(path) = fixture_path(file) else {
            eprintln!("skip {file} (not found)");
            continue;
        };

        eprintln!("\n=== {label} ===");

        // Phase 1: Count
        {
            let _prof = dhat::Profiler::builder().testing().build();
            let (_counts, _total) = count_sequences(&path, 0, false).unwrap();
            let s = dhat::HeapStats::get();
            eprintln!(
                "  count:   peak={:>10} bytes ({:>6} blocks), total={:>10} bytes ({:>6} allocs)",
                s.max_bytes, s.max_blocks, s.total_bytes, s.total_blocks
            );
        }

        // Run count again to get data for next phases
        let (counts, total) = {
            let _prof = dhat::Profiler::builder().testing().build();
            count_sequences(&path, 0, false).unwrap()
        };

        // Phase 2: Prepare
        {
            let _prof = dhat::Profiler::builder().testing().build();
            let _records = prepare_records(counts.clone());
            let s = dhat::HeapStats::get();
            eprintln!(
                "  prepare: peak={:>10} bytes ({:>6} blocks), total={:>10} bytes ({:>6} allocs)",
                s.max_bytes, s.max_blocks, s.total_bytes, s.total_blocks
            );
        }

        let records = prepare_records(counts);

        // Phase 3: Output CSV
        {
            let _prof = dhat::Profiler::builder().testing().build();
            let tmp = tempfile::NamedTempFile::with_suffix(".csv").unwrap();
            save_csv(&records, tmp.path(), b',', total, false).unwrap();
            let s = dhat::HeapStats::get();
            eprintln!(
                "  csv:     peak={:>10} bytes ({:>6} blocks), total={:>10} bytes ({:>6} allocs)",
                s.max_bytes, s.max_blocks, s.total_bytes, s.total_blocks
            );
        }

        // Phase 3: Output Parquet
        {
            let _prof = dhat::Profiler::builder().testing().build();
            let tmp = tempfile::NamedTempFile::with_suffix(".parquet").unwrap();
            save_parquet(
                &records,
                tmp.path(),
                parquet::basic::Compression::ZSTD(Default::default()),
                total,
                false,
            )
            .unwrap();
            let s = dhat::HeapStats::get();
            eprintln!(
                "  parquet: peak={:>10} bytes ({:>6} blocks), total={:>10} bytes ({:>6} allocs)",
                s.max_bytes, s.max_blocks, s.total_bytes, s.total_blocks
            );
        }
    }
}