From 6f78825876d2140d2182332da40f73aa05557573 Mon Sep 17 00:00:00 2001 From: Arthur Lu Date: Tue, 12 Nov 2024 18:44:12 +0000 Subject: [PATCH] optimize build size by avoiding fmt, pack lo/hi values into Wavefront --- go.mod | 8 +++--- main.go | 49 ++++++++++++++++++++++++----------- pkg/debug.go | 16 +++++++----- pkg/types.go | 66 ++++++++++++++++++++++-------------------------- test/wfa_test.go | 23 ++++++++++++++--- 5 files changed, 96 insertions(+), 66 deletions(-) diff --git a/go.mod b/go.mod index 0aa7e2b..9c42739 100644 --- a/go.mod +++ b/go.mod @@ -3,13 +3,13 @@ module wfa go 1.23.2 require ( - github.com/schollz/progressbar/v3 v3.17.0 - golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c + github.com/schollz/progressbar/v3 v3.17.1 + golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f ) require ( github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect github.com/rivo/uniseg v0.4.7 // indirect - golang.org/x/sys v0.26.0 // indirect - golang.org/x/term v0.25.0 // indirect + golang.org/x/sys v0.27.0 // indirect + golang.org/x/term v0.26.0 // indirect ) diff --git a/main.go b/main.go index da77e09..94d62e2 100644 --- a/main.go +++ b/main.go @@ -1,7 +1,6 @@ package main import ( - "fmt" "syscall/js" wfa "wfa/pkg" ) @@ -15,32 +14,47 @@ func main() { func wfAlign(this js.Value, args []js.Value) interface{} { if len(args) != 4 { - fmt.Println("invalid number of args, requires 4: s1, s2, penalties, doCIGAR") - return nil + resultMap := map[string]interface{}{ + "ok": false, + "error": "invalid number of args, requires 4: s1, s2, penalties, doCIGAR", + } + return js.ValueOf(resultMap) } if args[0].Type() != js.TypeString { - fmt.Println("s1 should be a string") - return nil + resultMap := map[string]interface{}{ + "ok": false, + "error": "s1 should be a string", + } + return js.ValueOf(resultMap) } s1 := args[0].String() if args[1].Type() != js.TypeString { - fmt.Println("s2 should be a string") - return nil + resultMap := map[string]interface{}{ + "ok": false, + "error": "s2 should be a string", + } + return js.ValueOf(resultMap) } s2 := args[1].String() if args[2].Type() != js.TypeObject { - fmt.Println("penalties should be a map with key values m, x, o, e") - return nil + resultMap := map[string]interface{}{ + "ok": false, + "error": "penalties should be a map with key values m, x, o, e", + } + return js.ValueOf(resultMap) } if args[2].Get("m").IsUndefined() || args[2].Get("x").IsUndefined() || args[2].Get("o").IsUndefined() || args[2].Get("e").IsUndefined() { - fmt.Println("penalties should be a map with key values m, x, o, e") - return nil + resultMap := map[string]interface{}{ + "ok": false, + "error": "penalties should be a map with key values m, x, o, e", + } + return js.ValueOf(resultMap) } m := args[2].Get("m").Int() @@ -56,8 +70,11 @@ func wfAlign(this js.Value, args []js.Value) interface{} { } if args[3].Type() != js.TypeBoolean { - fmt.Println("doCIGAR should be a boolean") - return nil + resultMap := map[string]interface{}{ + "ok": false, + "error": "doCIGAR should be a boolean", + } + return js.ValueOf(resultMap) } doCIGAR := args[3].Bool() @@ -65,8 +82,10 @@ func wfAlign(this js.Value, args []js.Value) interface{} { // Call the actual func. result := wfa.WFAlign(s1, s2, penalties, doCIGAR) resultMap := map[string]interface{}{ + "ok": true, "score": result.Score, "CIGAR": result.CIGAR, + "error": "", } return js.ValueOf(resultMap) @@ -74,12 +93,12 @@ func wfAlign(this js.Value, args []js.Value) interface{} { func DecodeCIGAR(this js.Value, args []js.Value) interface{} { if len(args) != 1 { - fmt.Println("invalid number of args, requires 1: CIGAR") + println("invalid number of args, requires 1: CIGAR") return nil } if args[0].Type() != js.TypeString { - fmt.Println("CIGAR should be a string") + println("CIGAR should be a string") return nil } diff --git a/pkg/debug.go b/pkg/debug.go index a3dd795..1df1e92 100644 --- a/pkg/debug.go +++ b/pkg/debug.go @@ -1,3 +1,5 @@ +//go:build debug + package wfa import ( @@ -12,11 +14,13 @@ func (w *WavefrontComponent) String(score int) string { max_hi := math.MinInt for i := 0; i <= score; i++ { - if w.lo.Valid(i) && w.lo.Get(i) < min_lo { - min_lo = w.lo.Get(i) + valid := w.W.Valid(i) + lo, hi := UnpackWavefrontLoHi(w.W.Get(i).lohi) + if valid && lo < min_lo { + min_lo = lo } - if w.hi.Valid(i) && w.hi.Get(i) > max_hi { - max_hi = w.hi.Get(i) + if valid && hi > max_hi { + max_hi = hi } } @@ -40,9 +44,7 @@ func (w *WavefrontComponent) String(score int) string { for i := 0; i <= score; i++ { s = s + "[" - lo := w.lo.Get(i) - hi := w.hi.Get(i) - // print out wavefront matrix + lo, hi := UnpackWavefrontLoHi(w.W.Get(i).lohi) for k := min_lo; k <= max_hi; k++ { valid, val, _ := UnpackWavefrontValue(w.W.Get(i).Get(k)) if valid { diff --git a/pkg/types.go b/pkg/types.go index cd5825d..fb93355 100644 --- a/pkg/types.go +++ b/pkg/types.go @@ -25,39 +25,55 @@ const ( End ) +// bitpacked wavefront lo/hi values with 32 bits each +type WavefrontLoHi uint64 + +func PackWavefrontLoHi(lo int, hi int) WavefrontLoHi { + loBM := int64(int32(lo)) & 0x0000_0000_FFFF_FFFF + hiBM := int64(int64(hi) << 32) + return WavefrontLoHi(hiBM | loBM) +} + +func UnpackWavefrontLoHi(lohi WavefrontLoHi) (int, int) { + loBM := int(int32(lohi & 0x0000_0000_FFFF_FFFF)) + hiBM := int(int32(lohi & 0xFFFF_FFFF_0000_0000 >> 32)) + return loBM, hiBM +} + // bitpacked wavefront values with 1 valid bit, 3 traceback bits, and 28 bits for the diag distance -// technically this restricts to solutions within 268 million score but that should be sufficient for most cases +// technically this restricts to alignments with less than 268 million characters but that should be sufficient for most cases type WavefrontValue uint32 -// TODO: add 64 bit packed value in case more than 268 million score is needed +// TODO: add 64 bit packed value in case more than 268 characters are needed // PackWavefrontValue: packs a diag value and traceback into a WavefrontValue func PackWavefrontValue(value uint32, traceback Traceback) WavefrontValue { - valueBM := value & 0x0FFF_FFFF + validBM := uint32(0x8000_0000) tracebackBM := uint32(traceback&0x0000_0007) << 28 - return WavefrontValue(0x8000_0000 | valueBM | tracebackBM) + valueBM := value & 0x0FFF_FFFF + return WavefrontValue(validBM | tracebackBM | valueBM) } // UnpackWavefrontValue: opens a WavefrontValue into a valid bool, diag value and traceback func UnpackWavefrontValue(wfv WavefrontValue) (bool, uint32, Traceback) { - valueBM := uint32(wfv & 0x0FFF_FFFF) - tracebackBM := uint8(wfv & 0x7000_0000 >> 28) validBM := wfv&0x8000_0000 != 0 + tracebackBM := uint8(wfv & 0x7000_0000 >> 28) + valueBM := uint32(wfv & 0x0FFF_FFFF) return validBM, valueBM, Traceback(tracebackBM) } // Wavefront: stores a single wavefront, stores wavefront's lo value and hi is naturally lo + len(data) type Wavefront struct { // since wavefronts store diag distance, they should never be negative, and traceback data can be stored as uint8 data []WavefrontValue - lo int + lohi WavefrontLoHi } // NewWavefront: returns a new wavefront with size accomodating lo and hi (inclusive) func NewWavefront(lo int, hi int) *Wavefront { a := &Wavefront{} - a.lo = lo - size := a.TranslateIndex(hi) + a.lohi = PackWavefrontLoHi(lo, hi) + size := hi - lo newData := make([]WavefrontValue, size+1) a.data = newData @@ -67,7 +83,8 @@ func NewWavefront(lo int, hi int) *Wavefront { // TranslateIndex: utility function for getting the data index given a diagonal func (a *Wavefront) TranslateIndex(diagonal int) int { - return diagonal - a.lo + lo := int(int32(a.lohi & 0x0000_0000_FFFF_FFFF)) + return diagonal - lo } // Get: returns WavefrontValue for given diagonal @@ -95,9 +112,7 @@ func (a *Wavefront) Set(diagonal int, value WavefrontValue) { // WavefrontComponent: each M/I/D wavefront matrix including the wavefront data, lo and hi type WavefrontComponent struct { - lo *PositiveSlice[int] // lo for each wavefront - hi *PositiveSlice[int] // hi for each wavefront - W *PositiveSlice[*Wavefront] // wavefront diag distance and traceback for each wavefront + W *PositiveSlice[*Wavefront] // wavefront diag distance and traceback for each wavefront } // NewWavefrontComponent: returns initialized WavefrontComponent @@ -108,14 +123,6 @@ func NewWavefrontComponent(preallocateSize int) *WavefrontComponent { // W = [] // } w := &WavefrontComponent{ - lo: &PositiveSlice[int]{ - data: []int{0}, - valid: []bool{true}, - }, - hi: &PositiveSlice[int]{ - data: []int{0}, - valid: []bool{true}, - }, W: &PositiveSlice[*Wavefront]{ defaultValue: &Wavefront{ data: []WavefrontValue{0}, @@ -123,8 +130,6 @@ func NewWavefrontComponent(preallocateSize int) *WavefrontComponent { }, } - w.lo.Preallocate(preallocateSize) - w.hi.Preallocate(preallocateSize) w.W.Preallocate(preallocateSize) return w @@ -142,23 +147,12 @@ func (w *WavefrontComponent) SetVal(score int, k int, val uint32, tb Traceback) // GetLoHi: get lo and hi for wavefront=score func (w *WavefrontComponent) GetLoHi(score int) (bool, int, int) { - // if lo[score] and hi[score] are valid - if w.lo.Valid(score) && w.hi.Valid(score) { - // return lo[score] hi[score] - return true, w.lo.Get(score), w.hi.Get(score) - } else { - return false, 0, 0 - } + lo, hi := UnpackWavefrontLoHi(w.W.Get(score).lohi) + return w.W.Valid(score), lo, hi } // SetLoHi: set lo and hi for wavefront=score func (w *WavefrontComponent) SetLoHi(score int, lo int, hi int) { - // lo[score] = lo - w.lo.Set(score, lo) - // hi[score] = hi - w.hi.Set(score, hi) - - // preemptively setup w.W b := NewWavefront(lo, hi) w.W.Set(score, b) } diff --git a/test/wfa_test.go b/test/wfa_test.go index 7fdee7d..6a7cdb3 100644 --- a/test/wfa_test.go +++ b/test/wfa_test.go @@ -12,6 +12,7 @@ import ( wfa "wfa/pkg" "github.com/schollz/progressbar/v3" + "golang.org/x/exp/constraints" ) const testJsonPath = "tests.json" @@ -29,14 +30,14 @@ type TestCase struct { Solutions string `json:"solutions"` } -func randRange(min, max int) uint32 { - return uint32(rand.IntN(max-min) + min) +func randRange[T constraints.Integer](min, max int) T { + return T(rand.IntN(max-min) + min) } func TestWavefrontPacking(t *testing.T) { for range 1000 { - val := randRange(0, 1000) - tb := wfa.Traceback(randRange(0, 7)) + val := randRange[uint32](0, 1000) + tb := wfa.Traceback(randRange[uint32](0, 7)) v := wfa.PackWavefrontValue(val, tb) valid, gotVal, gotTB := wfa.UnpackWavefrontValue(v) @@ -47,6 +48,20 @@ func TestWavefrontPacking(t *testing.T) { } } +func TestLoHiPacking(t *testing.T) { + for range 1000 { + lo := randRange[int](-1000, 1000) + hi := randRange[int](-1000, 1000) + v := wfa.PackWavefrontLoHi(lo, hi) + + gotLo, gotHi := wfa.UnpackWavefrontLoHi(v) + + if gotLo != lo || gotHi != hi { + t.Errorf(`test WavefrontPack/Unpack, lo: %d, hi: %d, packedval: %x, gotlo: %d, gothi: %d`, lo, hi, v, gotLo, gotHi) + } + } +} + func GetScoreFromCIGAR(CIGAR string, penalties wfa.Penalty) int { unpackedCIGAR := wfa.RunLengthDecode(CIGAR) previousOp := '~'