optimize build size by avoiding fmt,

pack lo/hi values into Wavefront
This commit is contained in:
Arthur Lu 2024-11-12 18:44:12 +00:00
parent a878da42a3
commit 6f78825876
5 changed files with 96 additions and 66 deletions

8
go.mod
View File

@ -3,13 +3,13 @@ module wfa
go 1.23.2 go 1.23.2
require ( require (
github.com/schollz/progressbar/v3 v3.17.0 github.com/schollz/progressbar/v3 v3.17.1
golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f
) )
require ( require (
github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
github.com/rivo/uniseg v0.4.7 // indirect github.com/rivo/uniseg v0.4.7 // indirect
golang.org/x/sys v0.26.0 // indirect golang.org/x/sys v0.27.0 // indirect
golang.org/x/term v0.25.0 // indirect golang.org/x/term v0.26.0 // indirect
) )

49
main.go
View File

@ -1,7 +1,6 @@
package main package main
import ( import (
"fmt"
"syscall/js" "syscall/js"
wfa "wfa/pkg" wfa "wfa/pkg"
) )
@ -15,32 +14,47 @@ func main() {
func wfAlign(this js.Value, args []js.Value) interface{} { func wfAlign(this js.Value, args []js.Value) interface{} {
if len(args) != 4 { if len(args) != 4 {
fmt.Println("invalid number of args, requires 4: s1, s2, penalties, doCIGAR") resultMap := map[string]interface{}{
return nil "ok": false,
"error": "invalid number of args, requires 4: s1, s2, penalties, doCIGAR",
}
return js.ValueOf(resultMap)
} }
if args[0].Type() != js.TypeString { if args[0].Type() != js.TypeString {
fmt.Println("s1 should be a string") resultMap := map[string]interface{}{
return nil "ok": false,
"error": "s1 should be a string",
}
return js.ValueOf(resultMap)
} }
s1 := args[0].String() s1 := args[0].String()
if args[1].Type() != js.TypeString { if args[1].Type() != js.TypeString {
fmt.Println("s2 should be a string") resultMap := map[string]interface{}{
return nil "ok": false,
"error": "s2 should be a string",
}
return js.ValueOf(resultMap)
} }
s2 := args[1].String() s2 := args[1].String()
if args[2].Type() != js.TypeObject { if args[2].Type() != js.TypeObject {
fmt.Println("penalties should be a map with key values m, x, o, e") resultMap := map[string]interface{}{
return nil "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() { 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") resultMap := map[string]interface{}{
return nil "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() 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 { if args[3].Type() != js.TypeBoolean {
fmt.Println("doCIGAR should be a boolean") resultMap := map[string]interface{}{
return nil "ok": false,
"error": "doCIGAR should be a boolean",
}
return js.ValueOf(resultMap)
} }
doCIGAR := args[3].Bool() doCIGAR := args[3].Bool()
@ -65,8 +82,10 @@ func wfAlign(this js.Value, args []js.Value) interface{} {
// Call the actual func. // Call the actual func.
result := wfa.WFAlign(s1, s2, penalties, doCIGAR) result := wfa.WFAlign(s1, s2, penalties, doCIGAR)
resultMap := map[string]interface{}{ resultMap := map[string]interface{}{
"ok": true,
"score": result.Score, "score": result.Score,
"CIGAR": result.CIGAR, "CIGAR": result.CIGAR,
"error": "",
} }
return js.ValueOf(resultMap) 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{} { func DecodeCIGAR(this js.Value, args []js.Value) interface{} {
if len(args) != 1 { if len(args) != 1 {
fmt.Println("invalid number of args, requires 1: CIGAR") println("invalid number of args, requires 1: CIGAR")
return nil return nil
} }
if args[0].Type() != js.TypeString { if args[0].Type() != js.TypeString {
fmt.Println("CIGAR should be a string") println("CIGAR should be a string")
return nil return nil
} }

View File

@ -1,3 +1,5 @@
//go:build debug
package wfa package wfa
import ( import (
@ -12,11 +14,13 @@ func (w *WavefrontComponent) String(score int) string {
max_hi := math.MinInt max_hi := math.MinInt
for i := 0; i <= score; i++ { for i := 0; i <= score; i++ {
if w.lo.Valid(i) && w.lo.Get(i) < min_lo { valid := w.W.Valid(i)
min_lo = w.lo.Get(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 { if valid && hi > max_hi {
max_hi = w.hi.Get(i) max_hi = hi
} }
} }
@ -40,9 +44,7 @@ func (w *WavefrontComponent) String(score int) string {
for i := 0; i <= score; i++ { for i := 0; i <= score; i++ {
s = s + "[" s = s + "["
lo := w.lo.Get(i) lo, hi := UnpackWavefrontLoHi(w.W.Get(i).lohi)
hi := w.hi.Get(i)
// print out wavefront matrix
for k := min_lo; k <= max_hi; k++ { for k := min_lo; k <= max_hi; k++ {
valid, val, _ := UnpackWavefrontValue(w.W.Get(i).Get(k)) valid, val, _ := UnpackWavefrontValue(w.W.Get(i).Get(k))
if valid { if valid {

View File

@ -25,39 +25,55 @@ const (
End 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 // 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 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 // PackWavefrontValue: packs a diag value and traceback into a WavefrontValue
func PackWavefrontValue(value uint32, traceback Traceback) WavefrontValue { func PackWavefrontValue(value uint32, traceback Traceback) WavefrontValue {
valueBM := value & 0x0FFF_FFFF validBM := uint32(0x8000_0000)
tracebackBM := uint32(traceback&0x0000_0007) << 28 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 // UnpackWavefrontValue: opens a WavefrontValue into a valid bool, diag value and traceback
func UnpackWavefrontValue(wfv WavefrontValue) (bool, uint32, Traceback) { func UnpackWavefrontValue(wfv WavefrontValue) (bool, uint32, Traceback) {
valueBM := uint32(wfv & 0x0FFF_FFFF)
tracebackBM := uint8(wfv & 0x7000_0000 >> 28)
validBM := wfv&0x8000_0000 != 0 validBM := wfv&0x8000_0000 != 0
tracebackBM := uint8(wfv & 0x7000_0000 >> 28)
valueBM := uint32(wfv & 0x0FFF_FFFF)
return validBM, valueBM, Traceback(tracebackBM) return validBM, valueBM, Traceback(tracebackBM)
} }
// Wavefront: stores a single wavefront, stores wavefront's lo value and hi is naturally lo + len(data) // 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 type Wavefront struct { // since wavefronts store diag distance, they should never be negative, and traceback data can be stored as uint8
data []WavefrontValue data []WavefrontValue
lo int lohi WavefrontLoHi
} }
// NewWavefront: returns a new wavefront with size accomodating lo and hi (inclusive) // NewWavefront: returns a new wavefront with size accomodating lo and hi (inclusive)
func NewWavefront(lo int, hi int) *Wavefront { func NewWavefront(lo int, hi int) *Wavefront {
a := &Wavefront{} a := &Wavefront{}
a.lo = lo a.lohi = PackWavefrontLoHi(lo, hi)
size := a.TranslateIndex(hi) size := hi - lo
newData := make([]WavefrontValue, size+1) newData := make([]WavefrontValue, size+1)
a.data = newData 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 // TranslateIndex: utility function for getting the data index given a diagonal
func (a *Wavefront) TranslateIndex(diagonal int) int { 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 // 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 // WavefrontComponent: each M/I/D wavefront matrix including the wavefront data, lo and hi
type WavefrontComponent struct { type WavefrontComponent struct {
lo *PositiveSlice[int] // lo for each wavefront W *PositiveSlice[*Wavefront] // wavefront diag distance and traceback for each wavefront
hi *PositiveSlice[int] // hi for each wavefront
W *PositiveSlice[*Wavefront] // wavefront diag distance and traceback for each wavefront
} }
// NewWavefrontComponent: returns initialized WavefrontComponent // NewWavefrontComponent: returns initialized WavefrontComponent
@ -108,14 +123,6 @@ func NewWavefrontComponent(preallocateSize int) *WavefrontComponent {
// W = [] // W = []
// } // }
w := &WavefrontComponent{ w := &WavefrontComponent{
lo: &PositiveSlice[int]{
data: []int{0},
valid: []bool{true},
},
hi: &PositiveSlice[int]{
data: []int{0},
valid: []bool{true},
},
W: &PositiveSlice[*Wavefront]{ W: &PositiveSlice[*Wavefront]{
defaultValue: &Wavefront{ defaultValue: &Wavefront{
data: []WavefrontValue{0}, data: []WavefrontValue{0},
@ -123,8 +130,6 @@ func NewWavefrontComponent(preallocateSize int) *WavefrontComponent {
}, },
} }
w.lo.Preallocate(preallocateSize)
w.hi.Preallocate(preallocateSize)
w.W.Preallocate(preallocateSize) w.W.Preallocate(preallocateSize)
return w 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 // GetLoHi: get lo and hi for wavefront=score
func (w *WavefrontComponent) GetLoHi(score int) (bool, int, int) { func (w *WavefrontComponent) GetLoHi(score int) (bool, int, int) {
// if lo[score] and hi[score] are valid lo, hi := UnpackWavefrontLoHi(w.W.Get(score).lohi)
if w.lo.Valid(score) && w.hi.Valid(score) { return w.W.Valid(score), lo, hi
// return lo[score] hi[score]
return true, w.lo.Get(score), w.hi.Get(score)
} else {
return false, 0, 0
}
} }
// SetLoHi: set lo and hi for wavefront=score // SetLoHi: set lo and hi for wavefront=score
func (w *WavefrontComponent) SetLoHi(score int, lo int, hi int) { 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) b := NewWavefront(lo, hi)
w.W.Set(score, b) w.W.Set(score, b)
} }

View File

@ -12,6 +12,7 @@ import (
wfa "wfa/pkg" wfa "wfa/pkg"
"github.com/schollz/progressbar/v3" "github.com/schollz/progressbar/v3"
"golang.org/x/exp/constraints"
) )
const testJsonPath = "tests.json" const testJsonPath = "tests.json"
@ -29,14 +30,14 @@ type TestCase struct {
Solutions string `json:"solutions"` Solutions string `json:"solutions"`
} }
func randRange(min, max int) uint32 { func randRange[T constraints.Integer](min, max int) T {
return uint32(rand.IntN(max-min) + min) return T(rand.IntN(max-min) + min)
} }
func TestWavefrontPacking(t *testing.T) { func TestWavefrontPacking(t *testing.T) {
for range 1000 { for range 1000 {
val := randRange(0, 1000) val := randRange[uint32](0, 1000)
tb := wfa.Traceback(randRange(0, 7)) tb := wfa.Traceback(randRange[uint32](0, 7))
v := wfa.PackWavefrontValue(val, tb) v := wfa.PackWavefrontValue(val, tb)
valid, gotVal, gotTB := wfa.UnpackWavefrontValue(v) 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 { func GetScoreFromCIGAR(CIGAR string, penalties wfa.Penalty) int {
unpackedCIGAR := wfa.RunLengthDecode(CIGAR) unpackedCIGAR := wfa.RunLengthDecode(CIGAR)
previousOp := '~' previousOp := '~'