diff options
| author | Pjotr <wrk@bosa.lan> | 2026-11-05 11:51:08 +0000 |
|---|---|---|
| committer | Pjotr <wrk@bosa.lan> | 2026-11-05 11:51:08 +0000 |
| commit | ff67b720f3d0c74739d8b8b657ac2e96bf171a1b (patch) | |
| tree | 611b7e39c97bf9168537835cd15267028a4e7f86 /src | |
| parent | b4ea4e3aaa9735c4d4342b98e3692cce52a40220 (diff) | |
| download | genenetwork4-ff67b720f3d0c74739d8b8b657ac2e96bf171a1b.tar.gz | |
gemma: key the gemma-wrapper cache dir by input set
The cache dir was keyed by chromosome only and shared across requests, so a request with different inputs (another trait, or another snps or genotype file) left a second *-gemma-cXX.tar.xz in the same chr-N dir. gemma-wrapper names those archives by a content hash, so the workflow's single-File glob output binding then matched more than one path and the step failed -- silently, since ravanan's user-error only logs when %log-level is set, which never happens inside a generated job script. Key the cache root by a hash of the input set (genotype path and size, snps contents, trait values, lmm) as well as by chromosome, so repeated identical requests still hit gemma-wrapper's cache while different input sets cannot see each other's archives. chromosomes_in reads the snps file, so it now takes the already-read contents (chromosomes_from) to avoid reading it twice. cwl/README.md: describe the two-part keying, and note that a node needs a writable HOME -- ravanan forwards the submitting process's HOME into the job (as sbatch would) and gemma-wrapper writes its lock file there.
Diffstat (limited to 'src')
| -rw-r--r-- | src/gemma.rs | 84 |
1 files changed, 67 insertions, 17 deletions
diff --git a/src/gemma.rs b/src/gemma.rs index 42a7de9..3f8db70 100644 --- a/src/gemma.rs +++ b/src/gemma.rs @@ -497,16 +497,18 @@ fn ravanan_output_paths<'a>(outputs: &'a Value, id: &str) -> Result<Vec<&'a str> .collect() } -/// The distinct chromosome names in `snps_file` (whitespace-separated: -/// rs id, position, chromosome), in first-seen order -- reproduces -/// gemma-wrapper's own `get_chromosomes`, used here to build -/// `compute_ravanan`'s `chromosomes` scatter input (CWL's `scatter` -/// needs a concrete array at invocation time, which can't be +/// The distinct chromosome names in a SNP annotation file's contents +/// (whitespace-separated: rs id, position, chromosome), in first-seen +/// order -- reproduces gemma-wrapper's own `get_chromosomes`, used here +/// to build `compute_ravanan`'s `chromosomes` scatter input (CWL's +/// `scatter` needs a concrete array at invocation time, which can't be /// discovered by a step inside the workflow itself without another /// round of plumbing -- see `cwl/gemma/gemma-loco.scm`'s own doc /// comment on this input). -fn chromosomes_in(snps_file: &str) -> Result<Vec<String>, GemmaError> { - let contents = std::fs::read_to_string(snps_file).map_err(GemmaError::Io)?; +/// +/// Takes the contents, not the path: the caller also hashes them (see +/// [`gemma_wrapper_input_key`]) and should not read the file twice. +fn chromosomes_from(contents: &str) -> Vec<String> { let mut seen = std::collections::HashSet::new(); let mut chromosomes = Vec::new(); for line in contents.lines() { @@ -516,7 +518,42 @@ fn chromosomes_in(snps_file: &str) -> Result<Vec<String>, GemmaError> { } } } - Ok(chromosomes) + chromosomes +} + +/// A stable identity for one request's GEMMA inputs, used to give each +/// distinct input set its own gemma-wrapper cache root (see +/// `compute_ravanan`). +/// +/// The genotype file is identified by its path and size rather than its +/// contents: hashing a genome-sized file on every request would cost +/// more than the cache saves, and the path is stable in practice (it is +/// the caller's own file, interned verbatim into ravanan's store). +fn gemma_wrapper_input_key( + genotype_file: &str, + snps_contents: &str, + trait_values: &TraitValues, + lmm: u8, +) -> String { + let mut material = Vec::new(); + material.extend_from_slice(genotype_file.as_bytes()); + material.push(0); + if let Ok(metadata) = std::fs::metadata(genotype_file) { + material.extend_from_slice(&metadata.len().to_le_bytes()); + } + material.push(0); + material.extend_from_slice(snps_contents.as_bytes()); + material.push(0); + material.extend_from_slice(lmm.to_string().as_bytes()); + material.push(0); + for value in trait_values { + match value { + Some(value) => material.extend_from_slice(&value.to_bits().to_le_bytes()), + None => material.extend_from_slice(b"NA"), + } + material.push(b','); + } + crate::indexer::sha256::hex_digest(&material)[..16].to_string() } /// The same GEMMA `--loco` kinship-then-GWA computation as `compute`, @@ -578,7 +615,8 @@ pub async fn compute_ravanan( std::fs::create_dir_all(store_dir.join(subdir)).map_err(GemmaError::Io)?; } - let chromosomes = chromosomes_in(snps_file)?; + let snps_contents = std::fs::read_to_string(snps_file).map_err(GemmaError::Io)?; + let chromosomes = chromosomes_from(&snps_contents); if chromosomes.is_empty() { return Err(GemmaError::NoAssocFiles); } @@ -588,15 +626,27 @@ pub async fn compute_ravanan( .collect::<Vec<_>>() .join(", "); - // One persistent cache directory per chromosome, reused across - // requests, so gemma-wrapper's content-hash cache actually gets hit - // on repeated identical requests -- unlike "." (each job's own - // hermetic CWL working directory under ravanan's --store, fresh + // A persistent cache directory per (input set, chromosome), reused + // across requests, so gemma-wrapper's content-hash cache actually + // gets hit on repeated identical requests -- unlike "." (each job's + // own hermetic CWL working directory under ravanan's --store, fresh // every run), which never accumulates a cache at all. Keyed by - // chromosome, not shared, because gemma-wrapper's cache-hit hash - // does not vary with --chromosomes: a shared directory would let - // one chromosome's job silently reuse another's cached result. - let wrapper_cache_dir = Path::new(cache_dir).join("gemma-wrapper-cache"); + // chromosome as well as the input set, because gemma-wrapper's + // cache-hit hash does not vary with --chromosomes: a directory + // shared between chromosomes would let one chromosome's job + // silently reuse another's cached result. + // + // Keyed by the input set too, because gemma-wrapper names its + // archives by a *content* hash: two different input sets (another + // trait, or another snps/genotype file) sharing a `chr-N` directory + // leave two `*-gemma-cXX.tar.xz` files there, and the CWL's + // single-File glob output binding (`$(inputs.cache_dir)/*-gemma-cXX.tar.xz`) + // then matches more than one path and the step fails -- with an + // error that ravanan's `user-error` silently drops in a job script. + let input_key = gemma_wrapper_input_key(genotype_file, &snps_contents, trait_values, lmm); + let wrapper_cache_dir = Path::new(cache_dir) + .join("gemma-wrapper-cache") + .join(&input_key); let mut chr_cache_dirs = Vec::new(); for chr in &chromosomes { let chr_cache_dir = wrapper_cache_dir.join(format!("chr-{chr}")); |
