alu/WFA-JS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 7 Wiki Activity

optimize build size by avoiding fmt,

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
go.mod
View File

@ -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
)

49
main.go
View File

@ -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
}

16
pkg/debug.go
View File

@ -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 {

64
pkg/types.go
View File

@ -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,8 +112,6 @@ 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
}
@ -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)
}

23
test/wfa_test.go
View File

@ -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 := '~'