"encoding/gob"
"fmt"
"io"
+ "runtime"
+ "sort"
"strings"
"sync"
}
type tileLibrary struct {
- includeNoCalls bool
- skipOOO bool
+ retainNoCalls bool
+ skipOOO bool
+ retainTileSequences bool
+
taglib *tagLibrary
variant [][][blake2b.Size256]byte
refseqs map[string]map[string][]tileLibRef
compactGenomes map[string][]tileVariantID
// count [][]int
- // seq map[[blake2b.Size]byte][]byte
+ seq map[[blake2b.Size256]byte][]byte
variants int
// if non-nil, write out any tile variants added while tiling
encoder *gob.Encoder
// match.
//
// If onLoadGenome is non-nil, call it on each CompactGenome entry.
-func (tilelib *tileLibrary) LoadGob(ctx context.Context, rdr io.Reader, onLoadGenome func(CompactGenome)) error {
+func (tilelib *tileLibrary) LoadGob(ctx context.Context, rdr io.Reader, gz bool, onLoadGenome func(CompactGenome)) error {
cgs := []CompactGenome{}
cseqs := []CompactSequence{}
variantmap := map[tileLibRef]tileVariantID{}
- err := DecodeLibrary(rdr, func(ent *LibraryEntry) error {
+ err := DecodeLibrary(rdr, gz, func(ent *LibraryEntry) error {
if ctx.Err() != nil {
return ctx.Err()
}
basesOut += countBases(job.fasta[last.pos+last.taglen : f.pos+f.taglen])
} else {
// If we dropped this tile
- // (because !includeNoCalls),
+ // (because !retainNoCalls),
// set taglen=0 so the
// overlapping tag is counted
// toward coverage on the
// Return a tileLibRef for a tile with the given tag and sequence,
// adding the sequence to the library if needed.
func (tilelib *tileLibrary) getRef(tag tagID, seq []byte) tileLibRef {
- if !tilelib.includeNoCalls {
+ dropSeq := false
+ if !tilelib.retainNoCalls {
for _, b := range seq {
if b != 'a' && b != 'c' && b != 'g' && b != 't' {
- // return "tile not found" if seq has any
- // no-calls
- return tileLibRef{Tag: tag}
+ dropSeq = true
+ break
}
}
}
tilelib.mtx.Lock()
- // if tilelib.seq == nil {
- // tilelib.seq = map[[blake2b.Size]byte][]byte{}
- // }
if tilelib.variant == nil && tilelib.taglib != nil {
tilelib.variant = make([][][blake2b.Size256]byte, tilelib.taglib.Len())
}
}
tilelib.variants++
tilelib.variant[tag] = append(tilelib.variant[tag], seqhash)
- // tilelib.seq[seqhash] = append([]byte(nil), seq...)
+ if tilelib.retainTileSequences && !dropSeq {
+ if tilelib.seq == nil {
+ tilelib.seq = map[[blake2b.Size256]byte][]byte{}
+ }
+ tilelib.seq[seqhash] = append([]byte(nil), seq...)
+ }
variant := tileVariantID(len(tilelib.variant[tag]))
tilelib.mtx.Unlock()
if tilelib.encoder != nil {
+ saveSeq := seq
+ if dropSeq {
+ // Save the hash, but not the sequence
+ saveSeq = nil
+ }
tilelib.encoder.Encode(LibraryEntry{
TileVariants: []TileVariant{{
Tag: tag,
Variant: variant,
Blake2b: seqhash,
- Sequence: seq,
+ Sequence: saveSeq,
}},
})
}
return tileLibRef{Tag: tag, Variant: variant}
}
+func (tilelib *tileLibrary) TileVariantSequence(libref tileLibRef) []byte {
+ if libref.Variant == 0 || len(tilelib.variant) <= int(libref.Tag) || len(tilelib.variant[libref.Tag]) < int(libref.Variant) {
+ return nil
+ }
+ return tilelib.seq[tilelib.variant[libref.Tag][libref.Variant-1]]
+}
+
+// Tidy deletes unreferenced tile variants and renumbers variants so
+// more common variants have smaller IDs.
+func (tilelib *tileLibrary) Tidy() {
+ log.Print("Tidy: compute inref")
+ inref := map[tileLibRef]bool{}
+ for _, refseq := range tilelib.refseqs {
+ for _, librefs := range refseq {
+ for _, libref := range librefs {
+ inref[libref] = true
+ }
+ }
+ }
+ log.Print("Tidy: compute remap")
+ remap := make([][]tileVariantID, len(tilelib.variant))
+ throttle := throttle{Max: runtime.NumCPU() + 1}
+ for tag, oldvariants := range tilelib.variant {
+ tag, oldvariants := tagID(tag), oldvariants
+ if tag%10000 == 0 {
+ log.Printf("Tidy: tag %d", tag)
+ }
+ throttle.Acquire()
+ go func() {
+ defer throttle.Release()
+ uses := make([]int, len(oldvariants))
+ for _, cg := range tilelib.compactGenomes {
+ for phase := 0; phase < 2; phase++ {
+ cgi := int(tag)*2 + phase
+ if cgi < len(cg) && cg[cgi] > 0 {
+ uses[cg[cgi]-1]++
+ }
+ }
+ }
+
+ // Compute desired order of variants:
+ // neworder[x] == index in oldvariants that
+ // should move to position x.
+ neworder := make([]int, len(oldvariants))
+ for i := range neworder {
+ neworder[i] = i
+ }
+ sort.Slice(neworder, func(i, j int) bool {
+ if cmp := uses[neworder[i]] - uses[neworder[j]]; cmp != 0 {
+ return cmp > 0
+ } else {
+ return bytes.Compare(oldvariants[neworder[i]][:], oldvariants[neworder[j]][:]) < 0
+ }
+ })
+
+ // Replace tilelib.variants[tag] with a new
+ // re-ordered slice of hashes, and make a
+ // mapping from old to new variant IDs.
+ remaptag := make([]tileVariantID, len(oldvariants)+1)
+ newvariants := make([][blake2b.Size256]byte, 0, len(neworder))
+ for _, oldi := range neworder {
+ if uses[oldi] > 0 || inref[tileLibRef{Tag: tag, Variant: tileVariantID(oldi + 1)}] {
+ newvariants = append(newvariants, oldvariants[oldi])
+ remaptag[oldi+1] = tileVariantID(len(newvariants))
+ }
+ }
+ tilelib.variant[tag] = newvariants
+ remap[tag] = remaptag
+ }()
+ }
+ throttle.Wait()
+
+ // Apply remap to genomes and reference sequences, so they
+ // refer to the same tile variants using the changed IDs.
+ log.Print("Tidy: apply remap")
+ for _, cg := range tilelib.compactGenomes {
+ for idx, variant := range cg {
+ cg[idx] = remap[tagID(idx/2)][variant]
+ }
+ }
+ for _, refcs := range tilelib.refseqs {
+ for _, refseq := range refcs {
+ for i, tv := range refseq {
+ refseq[i].Variant = remap[tv.Tag][tv.Variant]
+ }
+ }
+ }
+ log.Print("Tidy: done")
+}
+
func countBases(seq []byte) int {
n := 0
for _, c := range seq {
projects / lightning.git / blobdiff