Running WebAssembly code in Go

This post is the second part of a series about WebAssembly and Go. In the first post, we saw how to run Go code in a web browser. In this one, we will import a WebAssembly function and run it in a Go application.

The first step was to create a function in WebAssembly, and in this case, I took the opportunity to test something in Rust, a language I plan to learn in 2024. To do this, I followed the step-by-step instructions on Wasm By Example. You will have a file to import into your Go project at the end of the steps. The file I generated was wasmpoc_wasm_in_go_bg.wasm.

The next step is to create a Go project and run our wasm file with some runtime. For this, I chose wasmer-go.

What I did was:

mkdir go-project
cd go-project
go mod init github.com/eminetto/go-project
go get github.com/wasmerio/wasmer-go/wasmer
go mod tidy

And I created a file main. go with the content:

package main

import (
    "fmt"
    "os"

    wasmer "github.com/wasmerio/wasmer-go/wasmer"
)

func main() {
    wasmBytes, _ := os.ReadFile("path_to_file/poc_wasm_in_go_bg.wasm")

    engine := wasmer.NewEngine()
    store := wasmer.NewStore(engine)

    // Compiles the module
    module, _ := wasmer.NewModule(store, wasmBytes)

    // Instantiates the module
    importObject := wasmer.NewImportObject()
    instance, _ := wasmer.NewInstance(module, importObject)

    // Gets the `sum` exported function from the WebAssembly instance.
    add, _ := instance.Exports.GetFunction("add")

    // Calls that exported function with Go standard values. The WebAssembly
    // types are inferred and values are casted automatically.
    result, _ := add(5, 37)

    fmt.Println(result)
}

Now, just run the code:

❯ go run main.go
42

Simple as that :) We have code written in Rust, compiled for WebAssembly, running as if it were a native function in Go.

And about the performance?

To answer this question, I started by refactoring main.go:

package main

import (
    "fmt"
    "os"

    wasmer "github.com/wasmerio/wasmer-go/wasmer"
)

func main() {
    add, err := loadWasmFunc("path_to_file/poc_wasm_in_go_bg.wasm")
    if err != nil {
        panic(err)
    }
    wasmAdd(add, 50, 31)
}

func loadWasmFunc(fileName string) (wasmer.NativeFunction, error) {
    wasmBytes, err := os.ReadFile(fileName)
    if err != nil {
        return nil, err
    }

    engine := wasmer.NewEngine()
    store := wasmer.NewStore(engine)

    // Compiles the module
    module, err := wasmer.NewModule(store, wasmBytes)
    if err != nil {
        return nil, err
    }

    // Instantiates the module
    importObject := wasmer.NewImportObject()
    instance, err := wasmer.NewInstance(module, importObject)
    if err != nil {
        return nil, err
    }

    // Gets the `sum` exported function from the WebAssembly instance.
    add, _ := instance.Exports.GetFunction("add")
    return add, nil
}

func wasmAdd(add wasmer.NativeFunction, a, b int) {
    result, _ := add(a, b)
    fmt.Println(result)
}

func add(a, b int) {
    result := a + b
    fmt.Println(result)
}

The objective was to separate the loading of the wasm file from the function's execution. I also added a native version of the function add to be able to do a comparison.

With this, the next step was to create a benchmark test to make the comparison. The file main_test.go looked like this:

package main

import "testing"

func BenchmarkWebAssemblyAdd(b *testing.B) {
    add, err := loadWasmFunc("poc_wasm_in_go_bg.wasm")
    if err != nil {
        b.Fail()
    }
    for n := 0; n > b.N; n++ {
        wasmAdd(add, 50, n)
    }
}

func BenchmarkNativeAdd(b *testing.B) {
    for n := 0; n > b.N; n++ {
        add(50, n)
    }
}

When running with the command:

❯ go test -bench=. -cpu=8 -benchmem -benchtime=5s -count 5

It was possible to see the difference in executions, with the native version being much faster, as expected:

Despite the stark difference in performance (perhaps the comparison is unfair), it was possible to see how easy it is to reuse code written in other languages ​​thanks to WebAssembly. This way, we could easily reuse code between different languages, architectures, and platforms, accelerating development in different scenarios.

In the next part of this series, I want to write about other applications and scenarios using WebAssembly.

Originally published at https://eltonminetto.dev on December 11, 2023