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

Compare commits

base: alu/WFA-JS:v2.0.3
Branches Tags
alu/WFA-JS:main
alu/WFA-JS:v2.0.5 alu/WFA-JS:v2.0.4 alu/WFA-JS:v2.0.3 alu/WFA-JS:v2.0.2 alu/WFA-JS:v2.0.1 alu/WFA-JS:v2.0.0 alu/WFA-JS:v1.0.0 alu/WFA-JS:v0.0.2 alu/WFA-JS:0.0.1
..
compare: alu/WFA-JS:7bbd8f6eb31959f819d3affc7e14edb8e35a54af
Branches Tags
alu/WFA-JS:main
alu/WFA-JS:v2.0.5 alu/WFA-JS:v2.0.4 alu/WFA-JS:v2.0.3 alu/WFA-JS:v2.0.2 alu/WFA-JS:v2.0.1 alu/WFA-JS:v2.0.0 alu/WFA-JS:v1.0.0 alu/WFA-JS:v0.0.2 alu/WFA-JS:0.0.1
13 Commits
v2.0.3 .. 7bbd8f6eb3
Author SHA1 Message Date
alu 7bbd8f6eb3 switch compiler to go instead of tinygo, TODO: increases size significantly 2026-09-02 18:46:17 +00:00
alu ab5ab2b81b fix html issues 2026-09-02 16:09:32 +00:00
alu f53f344fb3 return wasm object directly 2026-07-29 16:13:32 +00:00
alu f8f8636cc3 update dev-init 2026-07-06 20:47:09 +00:00
alu 13b522f6a0 fix missing dist dir make issue 2026-07-06 20:40:48 +00:00
alu 05cd2d79df remove minification of wasm.js 2026-07-06 20:36:42 +00:00
alu bc52a250a4 update go mod 2026-07-06 18:44:32 +00:00
= 830c0a7586 update wfa.js, 
reduce clobbering of global namespaces
 2025-10-02 21:56:39 +00:00
= c94a7902c0 remove imports, 
switch to opt=s,
add debug index.html
 2025-09-30 17:41:14 +00:00
alu 8ccb45748d update go mod 2025-09-17 06:13:27 +00:00
alu 63a375995c minor code cleanup, use uint64 for wavefront values 2025-05-07 21:20:13 +00:00
alu 2351faf2d7 cleanup code 2025-05-01 18:04:42 +00:00
alu a446bbd923 fix readme, 
update go mod
 2025-03-12 00:09:18 +00:00
11 changed files with 474 additions and 406 deletions
Expand all files Collapse all files
Makefile
+8 -4
View File
@@ -1,9 +1,10 @@
.PHONY: build clean test .PHONY: build clean test dev-init
build: clean build: clean
@echo "======================== Building Binary =======================" @echo "======================== Building Binary ======================="
minify wfa.js > dist/wfa.js mkdir -p dist
GOOS=js GOARCH=wasm CGO_ENABLED=0 tinygo build -panic=trap -no-debug -opt=2 -target=wasm -o dist/wfa.wasm . cp wfa.js dist/wfa.js
GOOS=js GOARCH=wasm CGO_ENABLED=0 go build -ldflags="-s -w" -trimpath -o dist/wfa.wasm .
clean: clean:
@echo "======================== Cleaning Project ======================" @echo "======================== Cleaning Project ======================"
@@ -23,4 +24,7 @@ test:
go tool pprof -top mem.prof go tool pprof -top mem.prof
@rm -f mem.prof @rm -f mem.prof
@rm -f test.test @rm -f test.test
dev-init:
go get -t wfa/test
README.md
+1 -1
View File
@@ -1,6 +1,6 @@
# Using WFA-JS # Using WFA-JS
Download `wfa.js` and `wfa.wasm`from [releases](https://git.tronnet.net/tronnet/WFA-JS/releases) to your project. Add to your script: Download `wfa.js` and `wfa.wasm`from [releases](https://git.tronnet.net/alu/WFA-JS/releases) to your project. Add to your script:
``` ```
import wfa from "./wfa.js" import wfa from "./wfa.js"
go.mod
+5 -5
View File
@@ -1,15 +1,15 @@
module wfa module wfa
go 1.23.2 go 1.27.0
require ( require (
github.com/schollz/progressbar/v3 v3.17.1 github.com/schollz/progressbar/v3 v3.19.1
golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f golang.org/x/exp v0.0.0-20260611194520-c48552f49976
) )
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.27.0 // indirect golang.org/x/sys v0.46.0 // indirect
golang.org/x/term v0.26.0 // indirect golang.org/x/term v0.44.0 // indirect
) )
index.html
+31
View File
@@ -0,0 +1,31 @@
<!DOCTYPE html>
<html lang="en">
<head>
<script src="wfa.js" type="module"></script>
<script type="module">
import wfaInit from "./wfa.js";
wfaInit("dist/wfa.wasm");
window.addEventListener("DOMContentLoaded", () => {
document.querySelector("#submit").addEventListener("click", () => {
a = document.querySelector("#a").value
b = document.querySelector("#b").value
const penalties = {
m: 0,
x: 1,
o: 0,
e: 1
};
const { score, CIGAR } = wfa.wfAlign(a, b, penalties, true);
const alignment = wfa.DecodeCIGAR(CIGAR);
document.querySelector("#result").innerText = `${score}, ${CIGAR}, ${alignment}`;
})
});
</script>
</head>
<body>
<label>A: </label><input type="text" id="a">
<label>B: </label><input type="text" id="b">
<button id="submit" type="button">Submit</button>
<p><span>Result: </span><span id="result"></span></p>
</body>
</html>
main.go
+2 -2
View File
@@ -7,8 +7,8 @@ import (
func main() { func main() {
c := make(chan bool) c := make(chan bool)
js.Global().Set("wfAlign", js.FuncOf(wfAlign)) js.Global().Get("wfa").Set("wfAlign", js.FuncOf(wfAlign))
js.Global().Set("DecodeCIGAR", js.FuncOf(DecodeCIGAR)) js.Global().Get("wfa").Set("DecodeCIGAR", js.FuncOf(DecodeCIGAR))
<-c <-c
} }
pkg/custom_slice.go
+10 -17
View File
@@ -6,38 +6,31 @@ type PositiveSlice[T any] struct {
defaultValue T defaultValue T
} }
func (a *PositiveSlice[T]) TranslateIndex(idx int) int {
return idx
}
func (a *PositiveSlice[T]) Valid(idx int) bool { func (a *PositiveSlice[T]) Valid(idx int) bool {
actualIdx := a.TranslateIndex(idx) return 0 <= idx && idx < len(a.valid) && a.valid[idx]
return 0 <= actualIdx && actualIdx < len(a.valid) && a.valid[actualIdx]
} }
func (a *PositiveSlice[T]) Get(idx int) T { func (a *PositiveSlice[T]) Get(idx int) T {
actualIdx := a.TranslateIndex(idx) if 0 <= idx && idx < len(a.valid) && a.valid[idx] { // idx is in the slice
if 0 <= actualIdx && actualIdx < len(a.valid) && a.valid[actualIdx] { // idx is in the slice return a.data[idx]
return a.data[actualIdx]
} else { // idx is out of the slice } else { // idx is out of the slice
return a.defaultValue return a.defaultValue
} }
} }
func (a *PositiveSlice[T]) Set(idx int, value T) { func (a *PositiveSlice[T]) Set(idx int, value T) {
actualIdx := a.TranslateIndex(idx) if idx >= len(a.valid) { // idx is outside the slice
if actualIdx < 0 || actualIdx >= len(a.valid) { // idx is outside the slice // expand data array to 2*idx
// expand data array to actualIdx newData := make([]T, 2*idx+1)
newData := make([]T, 2*actualIdx+1)
copy(newData, a.data) copy(newData, a.data)
a.data = newData a.data = newData
// expand valid array to actualIdx // expand valid array to 2*idx
newValid := make([]bool, 2*actualIdx+1) newValid := make([]bool, 2*idx+1)
copy(newValid, a.valid) copy(newValid, a.valid)
a.valid = newValid a.valid = newValid
} }
a.data[actualIdx] = value a.data[idx] = value
a.valid[actualIdx] = true a.valid[idx] = true
} }
pkg/types.go
+17 -19
View File
@@ -1,5 +1,9 @@
package wfa package wfa
type Integer interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}
type Result struct { type Result struct {
Score int Score int
CIGAR string CIGAR string
@@ -40,25 +44,22 @@ func UnpackWavefrontLoHi(lohi WavefrontLoHi) (int, int) {
return loBM, hiBM 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 60 bits for the diag distance
// technically this restricts to alignments with less than 268 million characters but that should be sufficient for most cases type WavefrontValue uint64
type WavefrontValue uint32
// TODO: add 64 bit packed value in case more than 268 million 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 uint64, traceback Traceback) WavefrontValue {
validBM := uint32(0x8000_0000) validBM := uint64(0x8000_0000_0000_0000)
tracebackBM := uint32(traceback&0x0000_0007) << 28 tracebackBM := uint64(traceback&0x0000_0007) << 60
valueBM := value & 0x0FFF_FFFF valueBM := uint64(value) & 0x0FFF_FFFF_FFFF_FFFF
return WavefrontValue(validBM | tracebackBM | valueBM) 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, uint64, Traceback) {
validBM := wfv&0x8000_0000 != 0 validBM := wfv&0x8000_0000_0000_0000 != 0
tracebackBM := uint8(wfv & 0x7000_0000 >> 28) tracebackBM := uint8(wfv & 0x7000_0000_0000_0000 >> 60)
valueBM := uint32(wfv & 0x0FFF_FFFF) valueBM := uint64(wfv & 0x0000_0000_FFFF_FFFF)
return validBM, valueBM, Traceback(tracebackBM) return validBM, valueBM, Traceback(tracebackBM)
} }
@@ -71,12 +72,9 @@ type Wavefront struct { // since wavefronts store diag distance, they should nev
// 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.lohi = PackWavefrontLoHi(lo, hi) a.lohi = PackWavefrontLoHi(lo, hi)
size := hi - lo size := hi - lo
a.data = make([]WavefrontValue, size+1)
newData := make([]WavefrontValue, size+1)
a.data = newData
return a return a
} }
@@ -134,12 +132,12 @@ func NewWavefrontComponent() *WavefrontComponent {
} }
// GetVal: get value for wavefront=score, diag=k => returns ok, value, traceback // GetVal: get value for wavefront=score, diag=k => returns ok, value, traceback
func (w *WavefrontComponent) GetVal(score int, k int) (bool, uint32, Traceback) { func (w *WavefrontComponent) GetVal(score int, k int) (bool, uint64, Traceback) {
return UnpackWavefrontValue(w.W.Get(score).Get(k)) return UnpackWavefrontValue(w.W.Get(score).Get(k))
} }
// SetVal: set value, traceback for wavefront=score, diag=k // SetVal: set value, traceback for wavefront=score, diag=k
func (w *WavefrontComponent) SetVal(score int, k int, val uint32, tb Traceback) { func (w *WavefrontComponent) SetVal(score int, k int, val uint64, tb Traceback) {
w.W.Get(score).Set(k, PackWavefrontValue(val, tb)) w.W.Get(score).Set(k, PackWavefrontValue(val, tb))
} }
pkg/utils.go
+41 -41
View File
@@ -1,23 +1,18 @@
package wfa package wfa
import ( const MaxInt = int(^uint(0) >> 1)
"math" const MinInt = -MaxInt - 1
"strings"
"golang.org/x/exp/constraints"
)
// convert an unsigned into to string
func UIntToString(num uint) string { // num assumed to be positive func UIntToString(num uint) string { // num assumed to be positive
var builder strings.Builder str := []rune{}
for num > 0 { for num > 0 {
digit := num % 10 digit := num % 10
builder.WriteRune(rune('0' + digit)) str = append(str, rune('0'+digit))
num /= 10 num /= 10
} }
// Reverse the string as we built it in reverse order
str := []rune(builder.String())
for i, j := 0, len(str)-1; i < j; i, j = i+1, j-1 { for i, j := 0, len(str)-1; i < j; i, j = i+1, j-1 {
str[i], str[j] = str[j], str[i] str[i], str[j] = str[j], str[i]
} }
@@ -25,8 +20,9 @@ func UIntToString(num uint) string { // num assumed to be positive
return string(str) return string(str)
} }
// decode runlength encoded string such as CIGARs
func RunLengthDecode(encoded string) string { func RunLengthDecode(encoded string) string {
decoded := strings.Builder{} decoded := []rune{}
length := len(encoded) length := len(encoded)
i := 0 i := 0
@@ -42,45 +38,30 @@ func RunLengthDecode(encoded string) string {
if i < length { if i < length {
char := encoded[i] char := encoded[i]
for j := 0; j < runLength; j++ { for j := 0; j < runLength; j++ {
decoded.WriteByte(char) decoded = append(decoded, rune(char))
} }
i++ // Move past the character i++ // Move past the character
} }
} }
return decoded.String() return string(decoded)
} }
func SafeMin[T constraints.Integer](values []T, idx int) T { // given the min index, return the item in values at that index
func SafeMin[T Integer](values []T, idx int) T {
return values[idx] return values[idx]
} }
func SafeMax[T constraints.Integer](values []T, idx int) T { // given the max index, return the item in values at that index
func SafeMax[T Integer](values []T, idx int) T {
return values[idx] return values[idx]
} }
func SafeArgMax[T constraints.Integer](valids []bool, values []T) (bool, int) { // given array of values and corresponding array of valid flags, find the min of value which is valid or return false if there does not exist any
hasValid := false func SafeArgMin[T Integer](valids []bool, values []T) (bool, int) {
maxIndex := 0
maxValue := math.MinInt
for i := 0; i < len(valids); i++ {
if valids[i] && int(values[i]) > maxValue {
hasValid = true
maxIndex = i
maxValue = int(values[i])
}
}
if hasValid {
return true, maxIndex
} else {
return false, 0
}
}
func SafeArgMin[T constraints.Integer](valids []bool, values []T) (bool, int) {
hasValid := false hasValid := false
minIndex := 0 minIndex := 0
minValue := math.MaxInt minValue := MaxInt
for i := 0; i < len(valids); i++ { for i := 0; i < len(valids); i++ {
if valids[i] && int(values[i]) < minValue { if valids[i] && int(values[i]) < minValue {
hasValid = true hasValid = true
@@ -95,6 +76,22 @@ func SafeArgMin[T constraints.Integer](valids []bool, values []T) (bool, int) {
} }
} }
// given array of values and corresponding array of valid flags, find the max of value which is valid or return false if there does not exist any
func SafeArgMax[T Integer](valids []bool, values []T) (bool, int) {
hasValid := false
maxIndex := 0
maxValue := MinInt
for i := range valids {
if valids[i] && int(values[i]) > maxValue {
hasValid = true
maxIndex = i
maxValue = int(values[i])
}
}
return hasValid, maxIndex
}
// set the lext lo and hi bounds for wavefronts M, I, D
func NextLoHi(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty) (int, int) { func NextLoHi(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty) (int, int) {
x := penalties.X x := penalties.X
o := penalties.O o := penalties.O
@@ -125,6 +122,7 @@ func NextLoHi(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponen
return lo, hi return lo, hi
} }
// set the traceback and diag value for the next I wavefront
func NextI(M *WavefrontComponent, I *WavefrontComponent, score int, k int, penalties Penalty) { func NextI(M *WavefrontComponent, I *WavefrontComponent, score int, k int, penalties Penalty) {
o := penalties.O o := penalties.O
e := penalties.E e := penalties.E
@@ -132,13 +130,14 @@ func NextI(M *WavefrontComponent, I *WavefrontComponent, score int, k int, penal
a_ok, a, _ := M.GetVal(score-o-e, k-1) a_ok, a, _ := M.GetVal(score-o-e, k-1)
b_ok, b, _ := I.GetVal(score-e, k-1) b_ok, b, _ := I.GetVal(score-e, k-1)
ok, nextITraceback := SafeArgMax([]bool{a_ok, b_ok}, []uint32{a, b}) ok, nextITraceback := SafeArgMax([]bool{a_ok, b_ok}, []uint64{a, b})
nextIVal := SafeMax([]uint32{a, b}, nextITraceback) + 1 // important that the +1 is here nextIVal := SafeMax([]uint64{a, b}, nextITraceback) + 1 // important that the +1 is here
if ok { if ok {
I.SetVal(score, k, nextIVal, []Traceback{OpenIns, ExtdIns}[nextITraceback]) I.SetVal(score, k, nextIVal, []Traceback{OpenIns, ExtdIns}[nextITraceback])
} }
} }
// set the traceback and diag value for the next D wavefront
func NextD(M *WavefrontComponent, D *WavefrontComponent, score int, k int, penalties Penalty) { func NextD(M *WavefrontComponent, D *WavefrontComponent, score int, k int, penalties Penalty) {
o := penalties.O o := penalties.O
e := penalties.E e := penalties.E
@@ -146,13 +145,14 @@ func NextD(M *WavefrontComponent, D *WavefrontComponent, score int, k int, penal
a_ok, a, _ := M.GetVal(score-o-e, k+1) a_ok, a, _ := M.GetVal(score-o-e, k+1)
b_ok, b, _ := D.GetVal(score-e, k+1) b_ok, b, _ := D.GetVal(score-e, k+1)
ok, nextDTraceback := SafeArgMax([]bool{a_ok, b_ok}, []uint32{a, b}) ok, nextDTraceback := SafeArgMax([]bool{a_ok, b_ok}, []uint64{a, b})
nextDVal := SafeMax([]uint32{a, b}, nextDTraceback) nextDVal := SafeMax([]uint64{a, b}, nextDTraceback)
if ok { if ok {
D.SetVal(score, k, nextDVal, []Traceback{OpenDel, ExtdDel}[nextDTraceback]) D.SetVal(score, k, nextDVal, []Traceback{OpenDel, ExtdDel}[nextDTraceback])
} }
} }
// set the traceback and diag value for the next M wavefront
func NextM(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, k int, penalties Penalty) { func NextM(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, k int, penalties Penalty) {
x := penalties.X x := penalties.X
@@ -161,8 +161,8 @@ func NextM(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent,
b_ok, b, _ := I.GetVal(score, k) b_ok, b, _ := I.GetVal(score, k)
c_ok, c, _ := D.GetVal(score, k) c_ok, c, _ := D.GetVal(score, k)
ok, nextMTraceback := SafeArgMax([]bool{a_ok, b_ok, c_ok}, []uint32{a, b, c}) ok, nextMTraceback := SafeArgMax([]bool{a_ok, b_ok, c_ok}, []uint64{a, b, c})
nextMVal := SafeMax([]uint32{a, b, c}, nextMTraceback) nextMVal := SafeMax([]uint64{a, b, c}, nextMTraceback)
if ok { if ok {
M.SetVal(score, k, nextMVal, []Traceback{Sub, Ins, Del}[nextMTraceback]) M.SetVal(score, k, nextMVal, []Traceback{Sub, Ins, Del}[nextMTraceback])
} }
pkg/wfa.go
+21 -23
View File
@@ -1,14 +1,11 @@
package wfa package wfa
import ( // WFAlign takes strings s1, s2, penalties, and returns the score and CIGAR if doCIGAR is true
"strings"
)
func WFAlign(s1 string, s2 string, penalties Penalty, doCIGAR bool) Result { func WFAlign(s1 string, s2 string, penalties Penalty, doCIGAR bool) Result {
n := len(s1) n := len(s1)
m := len(s2) m := len(s2)
A_k := m - n A_k := m - n // diagonal where both sequences end
A_offset := uint32(m) A_offset := uint64(m) // offset along a_k diagonal corresponding to end
score := 0 score := 0
M := NewWavefrontComponent() M := NewWavefrontComponent()
M.SetLoHi(0, 0, 0) M.SetLoHi(0, 0, 0)
@@ -19,7 +16,7 @@ func WFAlign(s1 string, s2 string, penalties Penalty, doCIGAR bool) Result {
for { for {
WFExtend(M, s1, n, s2, m, score) WFExtend(M, s1, n, s2, m, score)
ok, val, _ := M.GetVal(score, A_k) ok, val, _ := M.GetVal(score, A_k)
if ok && val >= A_offset { if ok && val >= A_offset { // exit when M_(s,a_k) >= A_offset, ie the wavefront has reached the end
break break
} }
score = score + 1 score = score + 1
@@ -27,7 +24,7 @@ func WFAlign(s1 string, s2 string, penalties Penalty, doCIGAR bool) Result {
} }
CIGAR := "" CIGAR := ""
if doCIGAR { if doCIGAR { // if doCIGAR, then perform backtrace, otherwise just return the score
CIGAR = WFBacktrace(M, I, D, score, penalties, A_k, A_offset, s1, s2) CIGAR = WFBacktrace(M, I, D, score, penalties, A_k, A_offset, s1, s2)
} }
@@ -39,23 +36,24 @@ func WFAlign(s1 string, s2 string, penalties Penalty, doCIGAR bool) Result {
func WFExtend(M *WavefrontComponent, s1 string, n int, s2 string, m int, score int) { func WFExtend(M *WavefrontComponent, s1 string, n int, s2 string, m int, score int) {
_, lo, hi := M.GetLoHi(score) _, lo, hi := M.GetLoHi(score)
for k := lo; k <= hi; k++ { for k := lo; k <= hi; k++ { // for each diagonal in current wavefront
// v = M[score][k] - k // v = M[score][k] - k
// h = M[score][k] // h = M[score][k]
ok, hu, _ := M.GetVal(score, k) ok, uh, tb := M.GetVal(score, k)
h := int(hu) // exit early if M_(s,l) is invalid
v := h - k
// exit early if v or h are invalid
if !ok { if !ok {
continue continue
} }
for v < n && h < m && s1[v] == s2[h] { h := int(uh)
_, val, tb := M.GetVal(score, k) v := h - k
M.SetVal(score, k, val+1, tb) // in the paper, we do v++, h++, M_(s,k)++
// however, note that h = M_(s,k) so instead we just do v++, h++ and set M_(s,k) at the end
// this saves a some memory reads and writes
for v < n && h < m && s1[v] == s2[h] { // extend diagonal for the next set of matches
v++ v++
h++ h++
} }
M.SetVal(score, k, uint64(h), tb)
} }
} }
@@ -63,14 +61,14 @@ func WFNext(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent,
// get this score's lo, hi // get this score's lo, hi
lo, hi := NextLoHi(M, I, D, score, penalties) lo, hi := NextLoHi(M, I, D, score, penalties)
for k := lo; k <= hi; k++ { for k := lo; k <= hi; k++ { // for each diagonal, extend the matrices for the next wavefronts
NextI(M, I, score, k, penalties) NextI(M, I, score, k, penalties)
NextD(M, D, score, k, penalties) NextD(M, D, score, k, penalties)
NextM(M, I, D, score, k, penalties) NextM(M, I, D, score, k, penalties)
} }
} }
func WFBacktrace(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty, A_k int, A_offset uint32, s1 string, s2 string) string { func WFBacktrace(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontComponent, score int, penalties Penalty, A_k int, A_offset uint64, s1 string, s2 string) string {
x := penalties.X x := penalties.X
o := penalties.O o := penalties.O
e := penalties.E e := penalties.E
@@ -187,11 +185,11 @@ func WFBacktrace(M *WavefrontComponent, I *WavefrontComponent, D *WavefrontCompo
} }
} }
CIGAR := strings.Builder{} CIGAR := ""
for i := len(Ops) - 1; i > 0; i-- { for i := len(Ops) - 1; i > 0; i-- {
CIGAR.WriteString(UIntToString(Counts[i])) CIGAR += UIntToString(Counts[i])
CIGAR.WriteRune(Ops[i]) CIGAR += string(Ops[i])
} }
return CIGAR.String() return CIGAR
} }
test/wfa_test.go
+2 -2
View File
@@ -36,8 +36,8 @@ func randRange[T constraints.Integer](min, max int) T {
func TestWavefrontPacking(t *testing.T) { func TestWavefrontPacking(t *testing.T) {
for range 1000 { for range 1000 {
val := randRange[uint32](0, 1000) val := randRange[uint64](0, 1000)
tb := wfa.Traceback(randRange[uint32](0, 7)) tb := wfa.Traceback(randRange[uint64](0, 7))
v := wfa.PackWavefrontValue(val, tb) v := wfa.PackWavefrontValue(val, tb)
valid, gotVal, gotTB := wfa.UnpackWavefrontValue(v) valid, gotVal, gotTB := wfa.UnpackWavefrontValue(v)
wfa.js
+336 -292
View File
@@ -1,55 +1,26 @@
// wasm_exec.js from tinygo
// Copyright 2018 The Go Authors. All rights reserved. // Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
//
// This file has been modified for use by the TinyGo compiler. "use strict";
(() => { (() => {
// Map multiple JavaScript environments to a single common API,
// preferring web standards over Node.js API.
//
// Environments considered:
// - Browsers
// - Node.js
// - Electron
// - Parcel
if (typeof global !== "undefined") {
// global already exists
} else if (typeof window !== "undefined") {
window.global = window;
} else if (typeof self !== "undefined") {
self.global = self;
} else {
throw new Error("cannot export Go (neither global, window nor self is defined)");
}
if (!global.require && typeof require !== "undefined") {
global.require = require;
}
if (!global.fs && global.require) {
global.fs = require("node:fs");
}
const enosys = () => { const enosys = () => {
const err = new Error("not implemented"); const err = new Error("not implemented");
err.code = "ENOSYS"; err.code = "ENOSYS";
return err; return err;
}; };
if (!global.fs) { if (!globalThis.fs) {
let outputBuf = ""; let outputBuf = "";
global.fs = { globalThis.fs = {
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, O_DIRECTORY: -1 }, // unused
writeSync(fd, buf) { writeSync(fd, buf) {
outputBuf += decoder.decode(buf); outputBuf += decoder.decode(buf);
const nl = outputBuf.lastIndexOf("\n"); const nl = outputBuf.lastIndexOf("\n");
if (nl != -1) { if (nl != -1) {
console.log(outputBuf.substr(0, nl)); console.log(outputBuf.substring(0, nl));
outputBuf = outputBuf.substr(nl + 1); outputBuf = outputBuf.substring(nl + 1);
} }
return buf.length; return buf.length;
}, },
@@ -87,8 +58,8 @@
}; };
} }
if (!global.process) { if (!globalThis.process) {
global.process = { globalThis.process = {
getuid() { return -1; }, getuid() { return -1; },
getgid() { return -1; }, getgid() { return -1; },
geteuid() { return -1; }, geteuid() { return -1; },
@@ -102,52 +73,66 @@
} }
} }
if (!global.crypto) { if (!globalThis.path) {
const nodeCrypto = require("node:crypto"); globalThis.path = {
global.crypto = { resolve(...pathSegments) {
getRandomValues(b) { return pathSegments.join("/");
nodeCrypto.randomFillSync(b); }
}, }
};
} }
if (!global.performance) { if (!globalThis.crypto) {
global.performance = { throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
now() {
const [sec, nsec] = process.hrtime();
return sec * 1000 + nsec / 1000000;
},
};
} }
if (!global.TextEncoder) { if (!globalThis.performance) {
global.TextEncoder = require("node:util").TextEncoder; throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
} }
if (!global.TextDecoder) { if (!globalThis.TextEncoder) {
global.TextDecoder = require("node:util").TextDecoder; throw new Error("globalThis.TextEncoder is not available, polyfill required");
} }
// End of polyfills for common API. if (!globalThis.TextDecoder) {
throw new Error("globalThis.TextDecoder is not available, polyfill required");
}
const encoder = new TextEncoder("utf-8"); const encoder = new TextEncoder("utf-8");
const decoder = new TextDecoder("utf-8"); const decoder = new TextDecoder("utf-8");
let reinterpretBuf = new DataView(new ArrayBuffer(8));
var logLine = [];
global.Go = class { globalThis.Go = class {
constructor() { constructor() {
this._callbackTimeouts = new Map(); this.argv = ["js"];
this.env = {};
this.exit = (code) => {
if (code !== 0) {
console.warn("exit code:", code);
}
};
this._exitPromise = new Promise((resolve) => {
this._resolveExitPromise = resolve;
});
this._pendingEvent = null;
this._scheduledTimeouts = new Map();
this._nextCallbackTimeoutID = 1; this._nextCallbackTimeoutID = 1;
const mem = () => { const setInt64 = (addr, v) => {
// The buffer may change when requesting more memory. this.mem.setUint32(addr + 0, v, true);
return new DataView(this._inst.exports.memory.buffer); this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
} }
const unboxValue = (v_ref) => { const setInt32 = (addr, v) => {
reinterpretBuf.setBigInt64(0, v_ref, true); this.mem.setUint32(addr + 0, v, true);
const f = reinterpretBuf.getFloat64(0, true); }
const getInt64 = (addr) => {
const low = this.mem.getUint32(addr + 0, true);
const high = this.mem.getInt32(addr + 4, true);
return low + high * 4294967296;
}
const loadValue = (addr) => {
const f = this.mem.getFloat64(addr, true);
if (f === 0) { if (f === 0) {
return undefined; return undefined;
} }
@@ -155,77 +140,69 @@
return f; return f;
} }
const id = v_ref & 0xffffffffn; const id = this.mem.getUint32(addr, true);
return this._values[id]; return this._values[id];
} }
const storeValue = (addr, v) => {
const nanHead = 0x7FF80000;
const loadValue = (addr) => { if (typeof v === "number" && v !== 0) {
let v_ref = mem().getBigUint64(addr, true);
return unboxValue(v_ref);
}
const boxValue = (v) => {
const nanHead = 0x7FF80000n;
if (typeof v === "number") {
if (isNaN(v)) { if (isNaN(v)) {
return nanHead << 32n; this.mem.setUint32(addr + 4, nanHead, true);
this.mem.setUint32(addr, 0, true);
return;
} }
if (v === 0) { this.mem.setFloat64(addr, v, true);
return (nanHead << 32n) | 1n; return;
}
reinterpretBuf.setFloat64(0, v, true);
return reinterpretBuf.getBigInt64(0, true);
} }
switch (v) { if (v === undefined) {
case undefined: this.mem.setFloat64(addr, 0, true);
return 0n; return;
case null:
return (nanHead << 32n) | 2n;
case true:
return (nanHead << 32n) | 3n;
case false:
return (nanHead << 32n) | 4n;
} }
let id = this._ids.get(v); let id = this._ids.get(v);
if (id === undefined) { if (id === undefined) {
id = this._idPool.pop(); id = this._idPool.pop();
if (id === undefined) { if (id === undefined) {
id = BigInt(this._values.length); id = this._values.length;
} }
this._values[id] = v; this._values[id] = v;
this._goRefCounts[id] = 0; this._goRefCounts[id] = 0;
this._ids.set(v, id); this._ids.set(v, id);
} }
this._goRefCounts[id]++; this._goRefCounts[id]++;
let typeFlag = 1n; let typeFlag = 0;
switch (typeof v) { switch (typeof v) {
case "object":
if (v !== null) {
typeFlag = 1;
}
break;
case "string": case "string":
typeFlag = 2n; typeFlag = 2;
break; break;
case "symbol": case "symbol":
typeFlag = 3n; typeFlag = 3;
break; break;
case "function": case "function":
typeFlag = 4n; typeFlag = 4;
break; break;
} }
return id | ((nanHead | typeFlag) << 32n); this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
this.mem.setUint32(addr, id, true);
} }
const storeValue = (addr, v) => { const loadSlice = (addr) => {
let v_ref = boxValue(v); const array = getInt64(addr + 0);
mem().setBigUint64(addr, v_ref, true); const len = getInt64(addr + 8);
return new Uint8Array(this._inst.exports.mem.buffer, array, len);
} }
const loadSlice = (array, len, cap) => { const loadSliceOfValues = (addr) => {
return new Uint8Array(this._inst.exports.memory.buffer, array, len); const array = getInt64(addr + 0);
} const len = getInt64(addr + 8);
const loadSliceOfValues = (array, len, cap) => {
const a = new Array(len); const a = new Array(len);
for (let i = 0; i < len; i++) { for (let i = 0; i < len; i++) {
a[i] = loadValue(array + i * 8); a[i] = loadValue(array + i * 8);
@@ -233,74 +210,109 @@
return a; return a;
} }
const loadString = (ptr, len) => { const loadString = (addr) => {
return decoder.decode(new DataView(this._inst.exports.memory.buffer, ptr, len)); const saddr = getInt64(addr + 0);
const len = getInt64(addr + 8);
return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
}
const testCallExport = (a, b) => {
this._inst.exports.testExport0();
return this._inst.exports.testExport(a, b);
} }
const timeOrigin = Date.now() - performance.now(); const timeOrigin = Date.now() - performance.now();
this.importObject = { this.importObject = {
wasi_snapshot_preview1: { _gotest: {
// https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write add: (a, b) => a + b,
fd_write: function(fd, iovs_ptr, iovs_len, nwritten_ptr) { callExport: testCallExport,
let nwritten = 0;
if (fd == 1) {
for (let iovs_i=0; iovs_i<iovs_len;iovs_i++) {
let iov_ptr = iovs_ptr+iovs_i*8; // assuming wasm32
let ptr = mem().getUint32(iov_ptr + 0, true);
let len = mem().getUint32(iov_ptr + 4, true);
nwritten += len;
for (let i=0; i<len; i++) {
let c = mem().getUint8(ptr+i);
if (c == 13) { // CR
// ignore
} else if (c == 10) { // LF
// write line
let line = decoder.decode(new Uint8Array(logLine));
logLine = [];
console.log(line);
} else {
logLine.push(c);
}
}
}
} else {
console.error('invalid file descriptor:', fd);
}
mem().setUint32(nwritten_ptr, nwritten, true);
return 0;
},
fd_close: () => 0, // dummy
fd_fdstat_get: () => 0, // dummy
fd_seek: () => 0, // dummy
"proc_exit": (code) => {
if (global.process) {
// Node.js
process.exit(code);
} else {
// Can't exit in a browser.
throw 'trying to exit with code ' + code;
}
},
random_get: (bufPtr, bufLen) => {
crypto.getRandomValues(loadSlice(bufPtr, bufLen));
return 0;
},
}, },
gojs: { gojs: {
// func ticks() float64 // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
"runtime.ticks": () => { // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
return timeOrigin + performance.now(); // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
// This changes the SP, thus we have to update the SP used by the imported function.
// func wasmExit(code int32)
"runtime.wasmExit": (sp) => {
sp >>>= 0;
const code = this.mem.getInt32(sp + 8, true);
this.exited = true;
delete this._inst;
delete this._values;
delete this._goRefCounts;
delete this._ids;
delete this._idPool;
this.exit(code);
}, },
// func sleepTicks(timeout float64) // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
"runtime.sleepTicks": (timeout) => { "runtime.wasmWrite": (sp) => {
// Do not sleep, only reactivate scheduler after the given timeout. sp >>>= 0;
setTimeout(this._inst.exports.go_scheduler, timeout); const fd = getInt64(sp + 8);
const p = getInt64(sp + 16);
const n = this.mem.getInt32(sp + 24, true);
fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
},
// func resetMemoryDataView()
"runtime.resetMemoryDataView": (sp) => {
sp >>>= 0;
this.mem = new DataView(this._inst.exports.mem.buffer);
},
// func nanotime1() int64
"runtime.nanotime1": (sp) => {
sp >>>= 0;
setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
},
// func walltime() (sec int64, nsec int32)
"runtime.walltime": (sp) => {
sp >>>= 0;
const msec = (new Date).getTime();
setInt64(sp + 8, msec / 1000);
this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
},
// func scheduleTimeoutEvent(delay int64) int32
"runtime.scheduleTimeoutEvent": (sp) => {
sp >>>= 0;
const id = this._nextCallbackTimeoutID;
this._nextCallbackTimeoutID++;
this._scheduledTimeouts.set(id, setTimeout(
() => {
this._resume();
while (this._scheduledTimeouts.has(id)) {
// for some reason Go failed to register the timeout event, log and try again
// (temporary workaround for https://github.com/golang/go/issues/28975)
console.warn("scheduleTimeoutEvent: missed timeout event");
this._resume();
}
},
getInt64(sp + 8),
));
this.mem.setInt32(sp + 16, id, true);
},
// func clearTimeoutEvent(id int32)
"runtime.clearTimeoutEvent": (sp) => {
sp >>>= 0;
const id = this.mem.getInt32(sp + 8, true);
clearTimeout(this._scheduledTimeouts.get(id));
this._scheduledTimeouts.delete(id);
},
// func getRandomData(r []byte)
"runtime.getRandomData": (sp) => {
sp >>>= 0;
crypto.getRandomValues(loadSlice(sp + 8));
}, },
// func finalizeRef(v ref) // func finalizeRef(v ref)
"syscall/js.finalizeRef": (v_ref) => { "syscall/js.finalizeRef": (sp) => {
const id = mem().getUint32(unboxValue(v_ref), true); sp >>>= 0;
const id = this.mem.getUint32(sp + 8, true);
this._goRefCounts[id]--; this._goRefCounts[id]--;
if (this._goRefCounts[id] === 0) { if (this._goRefCounts[id] === 0) {
const v = this._values[id]; const v = this._values[id];
@@ -311,183 +323,233 @@
}, },
// func stringVal(value string) ref // func stringVal(value string) ref
"syscall/js.stringVal": (value_ptr, value_len) => { "syscall/js.stringVal": (sp) => {
const s = loadString(value_ptr, value_len); sp >>>= 0;
return boxValue(s); storeValue(sp + 24, loadString(sp + 8));
}, },
// func valueGet(v ref, p string) ref // func valueGet(v ref, p string) ref
"syscall/js.valueGet": (v_ref, p_ptr, p_len) => { "syscall/js.valueGet": (sp) => {
let prop = loadString(p_ptr, p_len); sp >>>= 0;
let v = unboxValue(v_ref); const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
let result = Reflect.get(v, prop); sp = this._inst.exports.getsp() >>> 0; // see comment above
return boxValue(result); storeValue(sp + 32, result);
}, },
// func valueSet(v ref, p string, x ref) // func valueSet(v ref, p string, x ref)
"syscall/js.valueSet": (v_ref, p_ptr, p_len, x_ref) => { "syscall/js.valueSet": (sp) => {
const v = unboxValue(v_ref); sp >>>= 0;
const p = loadString(p_ptr, p_len); Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
const x = unboxValue(x_ref);
Reflect.set(v, p, x);
}, },
// func valueDelete(v ref, p string) // func valueDelete(v ref, p string)
"syscall/js.valueDelete": (v_ref, p_ptr, p_len) => { "syscall/js.valueDelete": (sp) => {
const v = unboxValue(v_ref); sp >>>= 0;
const p = loadString(p_ptr, p_len); Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
Reflect.deleteProperty(v, p);
}, },
// func valueIndex(v ref, i int) ref // func valueIndex(v ref, i int) ref
"syscall/js.valueIndex": (v_ref, i) => { "syscall/js.valueIndex": (sp) => {
return boxValue(Reflect.get(unboxValue(v_ref), i)); sp >>>= 0;
storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
}, },
// valueSetIndex(v ref, i int, x ref) // valueSetIndex(v ref, i int, x ref)
"syscall/js.valueSetIndex": (v_ref, i, x_ref) => { "syscall/js.valueSetIndex": (sp) => {
Reflect.set(unboxValue(v_ref), i, unboxValue(x_ref)); sp >>>= 0;
Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
}, },
// func valueCall(v ref, m string, args []ref) (ref, bool) // func valueCall(v ref, m string, args []ref) (ref, bool)
"syscall/js.valueCall": (ret_addr, v_ref, m_ptr, m_len, args_ptr, args_len, args_cap) => { "syscall/js.valueCall": (sp) => {
const v = unboxValue(v_ref); sp >>>= 0;
const name = loadString(m_ptr, m_len);
const args = loadSliceOfValues(args_ptr, args_len, args_cap);
try { try {
const m = Reflect.get(v, name); const v = loadValue(sp + 8);
storeValue(ret_addr, Reflect.apply(m, v, args)); const m = Reflect.get(v, loadString(sp + 16));
mem().setUint8(ret_addr + 8, 1); const args = loadSliceOfValues(sp + 32);
const result = Reflect.apply(m, v, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 56, result);
this.mem.setUint8(sp + 64, 1);
} catch (err) { } catch (err) {
storeValue(ret_addr, err); sp = this._inst.exports.getsp() >>> 0; // see comment above
mem().setUint8(ret_addr + 8, 0); storeValue(sp + 56, err);
this.mem.setUint8(sp + 64, 0);
} }
}, },
// func valueInvoke(v ref, args []ref) (ref, bool) // func valueInvoke(v ref, args []ref) (ref, bool)
"syscall/js.valueInvoke": (ret_addr, v_ref, args_ptr, args_len, args_cap) => { "syscall/js.valueInvoke": (sp) => {
sp >>>= 0;
try { try {
const v = unboxValue(v_ref); const v = loadValue(sp + 8);
const args = loadSliceOfValues(args_ptr, args_len, args_cap); const args = loadSliceOfValues(sp + 16);
storeValue(ret_addr, Reflect.apply(v, undefined, args)); const result = Reflect.apply(v, undefined, args);
mem().setUint8(ret_addr + 8, 1); sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, result);
this.mem.setUint8(sp + 48, 1);
} catch (err) { } catch (err) {
storeValue(ret_addr, err); sp = this._inst.exports.getsp() >>> 0; // see comment above
mem().setUint8(ret_addr + 8, 0); storeValue(sp + 40, err);
this.mem.setUint8(sp + 48, 0);
} }
}, },
// func valueNew(v ref, args []ref) (ref, bool) // func valueNew(v ref, args []ref) (ref, bool)
"syscall/js.valueNew": (ret_addr, v_ref, args_ptr, args_len, args_cap) => { "syscall/js.valueNew": (sp) => {
const v = unboxValue(v_ref); sp >>>= 0;
const args = loadSliceOfValues(args_ptr, args_len, args_cap);
try { try {
storeValue(ret_addr, Reflect.construct(v, args)); const v = loadValue(sp + 8);
mem().setUint8(ret_addr + 8, 1); const args = loadSliceOfValues(sp + 16);
const result = Reflect.construct(v, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, result);
this.mem.setUint8(sp + 48, 1);
} catch (err) { } catch (err) {
storeValue(ret_addr, err); sp = this._inst.exports.getsp() >>> 0; // see comment above
mem().setUint8(ret_addr+ 8, 0); storeValue(sp + 40, err);
this.mem.setUint8(sp + 48, 0);
} }
}, },
// func valueLength(v ref) int // func valueLength(v ref) int
"syscall/js.valueLength": (v_ref) => { "syscall/js.valueLength": (sp) => {
return unboxValue(v_ref).length; sp >>>= 0;
setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
}, },
// valuePrepareString(v ref) (ref, int) // valuePrepareString(v ref) (ref, int)
"syscall/js.valuePrepareString": (ret_addr, v_ref) => { "syscall/js.valuePrepareString": (sp) => {
const s = String(unboxValue(v_ref)); sp >>>= 0;
const str = encoder.encode(s); const str = encoder.encode(String(loadValue(sp + 8)));
storeValue(ret_addr, str); storeValue(sp + 16, str);
mem().setInt32(ret_addr + 8, str.length, true); setInt64(sp + 24, str.length);
}, },
// valueLoadString(v ref, b []byte) // valueLoadString(v ref, b []byte)
"syscall/js.valueLoadString": (v_ref, slice_ptr, slice_len, slice_cap) => { "syscall/js.valueLoadString": (sp) => {
const str = unboxValue(v_ref); sp >>>= 0;
loadSlice(slice_ptr, slice_len, slice_cap).set(str); const str = loadValue(sp + 8);
loadSlice(sp + 16).set(str);
}, },
// func valueInstanceOf(v ref, t ref) bool // func valueInstanceOf(v ref, t ref) bool
"syscall/js.valueInstanceOf": (v_ref, t_ref) => { "syscall/js.valueInstanceOf": (sp) => {
return unboxValue(v_ref) instanceof unboxValue(t_ref); sp >>>= 0;
this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
}, },
// func copyBytesToGo(dst []byte, src ref) (int, bool) // func copyBytesToGo(dst []byte, src ref) (int, bool)
"syscall/js.copyBytesToGo": (ret_addr, dest_addr, dest_len, dest_cap, src_ref) => { "syscall/js.copyBytesToGo": (sp) => {
let num_bytes_copied_addr = ret_addr; sp >>>= 0;
let returned_status_addr = ret_addr + 4; // Address of returned boolean status variable const dst = loadSlice(sp + 8);
const src = loadValue(sp + 32);
const dst = loadSlice(dest_addr, dest_len);
const src = unboxValue(src_ref);
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) { if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
mem().setUint8(returned_status_addr, 0); // Return "not ok" status this.mem.setUint8(sp + 48, 0);
return; return;
} }
const toCopy = src.subarray(0, dst.length); const toCopy = src.subarray(0, dst.length);
dst.set(toCopy); dst.set(toCopy);
mem().setUint32(num_bytes_copied_addr, toCopy.length, true); setInt64(sp + 40, toCopy.length);
mem().setUint8(returned_status_addr, 1); // Return "ok" status this.mem.setUint8(sp + 48, 1);
}, },
// copyBytesToJS(dst ref, src []byte) (int, bool) // func copyBytesToJS(dst ref, src []byte) (int, bool)
// Originally copied from upstream Go project, then modified: "syscall/js.copyBytesToJS": (sp) => {
// https://github.com/golang/go/blob/3f995c3f3b43033013013e6c7ccc93a9b1411ca9/misc/wasm/wasm_exec.js#L404-L416 sp >>>= 0;
"syscall/js.copyBytesToJS": (ret_addr, dst_ref, src_addr, src_len, src_cap) => { const dst = loadValue(sp + 8);
let num_bytes_copied_addr = ret_addr; const src = loadSlice(sp + 16);
let returned_status_addr = ret_addr + 4; // Address of returned boolean status variable
const dst = unboxValue(dst_ref);
const src = loadSlice(src_addr, src_len);
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) { if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
mem().setUint8(returned_status_addr, 0); // Return "not ok" status this.mem.setUint8(sp + 48, 0);
return; return;
} }
const toCopy = src.subarray(0, dst.length); const toCopy = src.subarray(0, dst.length);
dst.set(toCopy); dst.set(toCopy);
mem().setUint32(num_bytes_copied_addr, toCopy.length, true); setInt64(sp + 40, toCopy.length);
mem().setUint8(returned_status_addr, 1); // Return "ok" status this.mem.setUint8(sp + 48, 1);
},
"debug": (value) => {
console.log(value);
}, },
} }
}; };
// Go 1.20 uses 'env'. Go 1.21 uses 'gojs'.
// For compatibility, we use both as long as Go 1.20 is supported.
this.importObject.env = this.importObject.gojs;
} }
async run(instance) { async run(instance) {
if (!(instance instanceof WebAssembly.Instance)) {
throw new Error("Go.run: WebAssembly.Instance expected");
}
this._inst = instance; this._inst = instance;
this.mem = new DataView(this._inst.exports.mem.buffer);
this._values = [ // JS values that Go currently has references to, indexed by reference id this._values = [ // JS values that Go currently has references to, indexed by reference id
NaN, NaN,
0, 0,
null, null,
true, true,
false, false,
global, globalThis,
this, this,
]; ];
this._goRefCounts = []; // number of references that Go has to a JS value, indexed by reference id this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
this._ids = new Map(); // mapping from JS values to reference ids this._ids = new Map([ // mapping from JS values to reference ids
this._idPool = []; // unused ids that have been garbage collected [0, 1],
this.exited = false; // whether the Go program has exited [null, 2],
[true, 3],
[false, 4],
[globalThis, 5],
[this, 6],
]);
this._idPool = []; // unused ids that have been garbage collected
this.exited = false; // whether the Go program has exited
while (true) { // Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
const callbackPromise = new Promise((resolve) => { let offset = 4096;
this._resolveCallbackPromise = () => {
if (this.exited) { const strPtr = (str) => {
throw new Error("bad callback: Go program has already exited"); const ptr = offset;
} const bytes = encoder.encode(str + "\0");
setTimeout(resolve, 0); // make sure it is asynchronous new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
}; offset += bytes.length;
}); if (offset % 8 !== 0) {
this._inst.exports._start(); offset += 8 - (offset % 8);
if (this.exited) {
break;
} }
await callbackPromise; return ptr;
};
const argc = this.argv.length;
const argvPtrs = [];
this.argv.forEach((arg) => {
argvPtrs.push(strPtr(arg));
});
argvPtrs.push(0);
const keys = Object.keys(this.env).sort();
keys.forEach((key) => {
argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
});
argvPtrs.push(0);
const argv = offset;
argvPtrs.forEach((ptr) => {
this.mem.setUint32(offset, ptr, true);
this.mem.setUint32(offset + 4, 0, true);
offset += 8;
});
// The linker guarantees global data starts from at least wasmMinDataAddr.
// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
const wasmMinDataAddr = 4096 + 8192;
if (offset >= wasmMinDataAddr) {
throw new Error("total length of command line and environment variables exceeds limit");
} }
this._inst.exports.run(argc, argv);
if (this.exited) {
this._resolveExitPromise();
}
await this._exitPromise;
} }
_resume() { _resume() {
@@ -510,51 +572,33 @@
}; };
} }
} }
if (
global.require &&
global.require.main === module &&
global.process &&
global.process.versions &&
!global.process.versions.electron
) {
if (process.argv.length != 3) {
console.error("usage: go_js_wasm_exec [wasm binary] [arguments]");
process.exit(1);
}
const go = new Go();
WebAssembly.instantiate(fs.readFileSync(process.argv[2]), go.importObject).then((result) => {
return go.run(result.instance);
}).catch((err) => {
console.error(err);
process.exit(1);
});
}
})(); })();
// wasm setup code // wasm setup code
export default function init (path) { export default function init (path) {
if (typeof global === "undefined") {
var global = globalThis;
}
return new Promise ((res) => { return new Promise ((res) => {
const go = new Go(); const go = new Go();
var wasm; const run = (obj) => {
const wasm = obj.instance;
global.wfa = wasm
go.run(wasm);
res(wasm)
}
if ('instantiateStreaming' in WebAssembly) { if ('instantiateStreaming' in WebAssembly) {
WebAssembly.instantiateStreaming(fetch(path), go.importObject).then(function (obj) { WebAssembly.instantiateStreaming(fetch(path), go.importObject).then(function (obj) {
wasm = obj.instance; run(obj)
go.run(wasm);
res()
}) })
} else { } else {
fetch(path).then(resp => fetch(path).then(resp =>
resp.arrayBuffer() resp.arrayBuffer()
).then(bytes => ).then(bytes =>
WebAssembly.instantiate(bytes, go.importObject).then(function (obj) { WebAssembly.instantiate(bytes, go.importObject).then(function (obj) {
wasm = obj.instance; run(obj)
go.run(wasm);
res()
}) })
) )
} }
}) })
} }