Apakah percikan api yang akan timbul apabila Golang dan Lua bertemu?

Artikel ini diperkenalkan oleh ruangan tutorial go language untuk memperkenalkan Golang dan Lua kepada semua orang saya harap ia dapat membantu rakan-rakan yang memerlukan.

Semasa bermain-main di GitHub, saya secara tidak sengaja menemui gopher-lua, iaitu mesin maya Lua yang dilaksanakan dalam Golang tulen. Kami tahu bahawa Golang adalah bahasa statik, manakala Lua adalah bahasa dinamik dan kecekapan Golang adalah sangat baik di kalangan bahasa lain, tetapi dari segi keupayaan dinamik, ia pasti tidak setanding dengan Lua. Jadi jika kita boleh menggabungkan kedua-duanya, kita boleh menggabungkan kekuatan masing-masing (manual lucu.

Dalam projek Wiki, kita boleh tahu bahawa kecekapan pelaksanaan dan prestasi gopher-lua hanya lebih baik daripada yang dilaksanakan dalam C Pengikatan adalah lemah. Oleh itu, dari perspektif prestasi, ini sepatutnya menjadi penyelesaian mesin maya yang sangat baik . Kami mula-mula mencipta mesin maya baharu, kemudian melakukan DoString(...) untuk mentafsir dan melaksanakan kod lua, dan akhirnya menutup mesin maya Apabila kami melaksanakan program, kami akan melihat aksara "Hello World" pada arahan baris.

Disusun terlebih dahulu

Selepas melihat rantai panggilan kaedah DoString(...) di atas, kami mendapati bahawa setiap kali DoString(... ) atau DoFile(...), parse dan compile akan dilaksanakan sekali setiap satu

package main
import (
"github.com/yuin/gopher-lua"
)
func main() {
l := lua.NewState()
defer l.Close()
if err := l.DoString(`print("Hello World")`); err != nil {
panic(err)
}
}
// Hello World

Dari sudut pandangan ini, kod Lua yang sama akan dilaksanakan beberapa kali (seperti. dalam pelayan http, setiap kali Dalam senario di mana permintaan akan melaksanakan kod Lua yang sama), jika kita boleh menyusun kod terlebih dahulu, kita sepatutnya dapat mengurangkan overhed parse dan compile (jika ini adalah kod laluan panas) . Menurut hasil Penanda Aras, kompilasi awal sememangnya boleh mengurangkan overhead yang tidak diperlukan . dilaksanakan, selain menggunakan kompilasi lebih awal untuk mengoptimumkan prestasi, kami juga boleh memperkenalkan kumpulan contoh mesin maya

Oleh kerana mencipta mesin maya Lua melibatkan banyak operasi peruntukan memori, jika ia dicipta semula dan. dimusnahkan setiap kali ia dijalankan, sejumlah besar sumber akan digunakan , boleh menggunakan semula mesin maya dan mengurangkan overhed yang tidak perlu

func (ls *LState) DoString(source string) error {
if fn, err := ls.LoadString(source); err != nil {
return err
} else {
ls.Push(fn)
return ls.PCall(0, MultRet, nil)
}
}
func (ls *LState) LoadString(source string) (*LFunction, error) {
return ls.Load(strings.NewReader(source), "<string>")
}
func (ls *LState) Load(reader io.Reader, name string) (*LFunction, error) {
chunk, err := parse.Parse(reader, name)
// ...
proto, err := Compile(chunk, name)
// ...
}

Hasil penanda aras menunjukkan bahawa kumpulan contoh mesin maya sememangnya boleh mengurangkan banyak operasi peruntukan memori. .

README disediakan di bawah, tetapi perhatikan bahawa dalam keadaan awal, pelaksanaan tidak menghasilkan tika mesin maya yang mencukupi (pada mulanya, bilangan tika ialah 0), dan terdapat dinamik. masalah pengembangan kepingan, yang merupakan bidang yang patut diperbaiki

package glua_test
import (
"bufio"
"os"
"strings"
lua "github.com/yuin/gopher-lua"
"github.com/yuin/gopher-lua/parse"
)
// 编译 lua 代码字段
func CompileString(source string) (*lua.FunctionProto, error) {
reader := strings.NewReader(source)
chunk, err := parse.Parse(reader, source)
if err != nil {
return nil, err
}
proto, err := lua.Compile(chunk, source)
if err != nil {
return nil, err
}
return proto, nil
}
// 编译 lua 代码文件
func CompileFile(filePath string) (*lua.FunctionProto, error) {
file, err := os.Open(filePath)
defer file.Close()
if err != nil {
return nil, err
}
reader := bufio.NewReader(file)
chunk, err := parse.Parse(reader, filePath)
if err != nil {
return nil, err
}
proto, err := lua.Compile(chunk, filePath)
if err != nil {
return nil, err
}
return proto, nil
}
func BenchmarkRunWithoutPreCompiling(b *testing.B) {
l := lua.NewState()
for i := 0; i < b.N; i++ {
_ = l.DoString(`a = 1 + 1`)
}
l.Close()
}
func BenchmarkRunWithPreCompiling(b *testing.B) {
l := lua.NewState()
proto, _ := CompileString(`a = 1 + 1`)
lfunc := l.NewFunctionFromProto(proto)
for i := 0; i < b.N; i++ {
l.Push(lfunc)
_ = l.PCall(0, lua.MultRet, nil)
}
l.Close()
}
// goos: darwin
// goarch: amd64
// pkg: glua
// BenchmarkRunWithoutPreCompiling-8         100000             19392 ns/op           85626 B/op         67 allocs/op
// BenchmarkRunWithPreCompiling-8           1000000              1162 ns/op            2752 B/op          8 allocs/op
// PASS
// ok      glua    3.328s

Panggilan modul

gopher-lua menyokong Lua untuk memanggil modul Go adalah ciri yang sangat menarik, kerana dalam program Golang Semasa pembangunan, kami mungkin mereka bentuk banyak modul yang biasa digunakan ini. Mekanisme panggilan silang bahasa ini membolehkan kami menggunakan semula kod dan alatan Pergi modul yang memanggil Lua , tetapi saya secara peribadi merasakan bahawa yang kedua tidak diperlukan, jadi yang terakhir tidak dibincangkan di sini.

func BenchmarkRunWithoutPool(b *testing.B) {
for i := 0; i < b.N; i++ {
l := lua.NewState()
_ = l.DoString(`a = 1 + 1`)
l.Close()
}
}
func BenchmarkRunWithPool(b *testing.B) {
pool := newVMPool(nil, 100)
for i := 0; i < b.N; i++ {
l := pool.get()
_ = l.DoString(`a = 1 + 1`)
pool.put(l)
}
}
// goos: darwin
// goarch: amd64
// pkg: glua
// BenchmarkRunWithoutPool-8          10000            129557 ns/op          262599 B/op        826 allocs/op
// BenchmarkRunWithPool-8            100000             19320 ns/op           85626 B/op         67 allocs/op
// PASS
// ok      glua    3.467s

Pencemaran boleh ubah

Apabila kita menggunakan kolam contoh untuk mengurangkan overhed, satu lagi masalah berduri akan diperkenalkan: kerana mesin maya yang sama boleh digunakan beberapa kali Laksanakan kod Lua yang sama dan menukar pembolehubah global di dalamnya. Jika logik kod bergantung pada pembolehubah global, hasil larian yang tidak dapat diramalkan mungkin berlaku (ini berbau sedikit seperti "bacaan tidak boleh diulang" dalam pengasingan pangkalan data).

type lStatePool struct {
    m     sync.Mutex
    saved []*lua.LState
}
func (pl *lStatePool) Get() *lua.LState {
    pl.m.Lock()
    defer pl.m.Unlock()
    n := len(pl.saved)
    if n == 0 {
        return pl.New()
    }
    x := pl.saved[n-1]
    pl.saved = pl.saved[0 : n-1]
    return x
}
func (pl *lStatePool) New() *lua.LState {
    L := lua.NewState()
    // setting the L up here.
    // load scripts, set global variables, share channels, etc...
    return L
}
func (pl *lStatePool) Put(L *lua.LState) {
    pl.m.Lock()
    defer pl.m.Unlock()
    pl.saved = append(pl.saved, L)
}
func (pl *lStatePool) Shutdown() {
    for _, L := range pl.saved {
        L.Close()
    }
}
// Global LState pool
var luaPool = &lStatePool{
    saved: make([]*lua.LState, 0, 4),
}

Pembolehubah global

Jika kita perlu mengehadkan kod Lua untuk hanya menggunakan pembolehubah tempatan, maka dari titik permulaan ini, kita perlu mengehadkan pembolehubah global. Jadi persoalannya, bagaimana untuk mencapainya?

Kami tahu bahawa Lua disusun menjadi kod bait dan kemudian ditafsir dan dilaksanakan. Kemudian, kita boleh menyekat penggunaan pembolehubah global semasa peringkat penyusunan bytecode. Selepas menyemak arahan mesin maya Lua, saya mendapati terdapat dua arahan yang melibatkan pembolehubah global: GETGLOBAL (Opcode 5) dan SETGLOBAL (Opcode 7).

package main
import (
"fmt"
lua "github.com/yuin/gopher-lua"
)
const source = `
local m = require("gomodule")
m.goFunc()
print(m.name)
`
func main() {
L := lua.NewState()
defer L.Close()
L.PreloadModule("gomodule", load)
if err := L.DoString(source); err != nil {
panic(err)
}
}
func load(L *lua.LState) int {
mod := L.SetFuncs(L.NewTable(), exports)
L.SetField(mod, "name", lua.LString("gomodule"))
L.Push(mod)
return 1
}
var exports = map[string]lua.LGFunction{
"goFunc": goFunc,
}
func goFunc(L *lua.LState) int {
fmt.Println("golang")
return 0
}
// golang
// gomodule

Pada ketika ini, kita sudah mempunyai idea umum: kita boleh mengehadkan penggunaan pembolehubah global dalam kod dengan menentukan sama ada bytecode mengandungi GETGLOBAL dan SETGLOBAL. Bagi mendapatkan bytecode, anda boleh mendapatkan FunctionProto kod Lua dengan memanggil CompileString(...) dan CompileFile(...), dan atribut Kod ialah keping bytecode, jenis []uint32.

Dalam kod pelaksanaan mesin maya, kita boleh mencari fungsi alat yang mengeluarkan OpCode yang sepadan berdasarkan kod bait.

Dengan fungsi alat ini, kita boleh menyemak pembolehubah global.

Modul

Selain pembolehubah yang berpotensi tercemar, modul Go yang diimport juga mungkin diganggu semasa masa jalan. Oleh itu, kami memerlukan mekanisme untuk memastikan modul yang diimport ke dalam mesin maya tidak diusik, iaitu objek yang diimport adalah baca sahaja.

Selepas berunding dengan blog yang berkaitan, kami boleh mengubah suai kaedah __newindex Jadual untuk menetapkan modul kepada mod baca sahaja.

Ditulis pada penghujung

// 获取对应指令的 OpCode
func opGetOpCode(inst uint32) int {
return int(inst >> 26)
}

Integrasi Golang dan Lua telah meluaskan ufuk saya: Ternyata bahasa statik dan bahasa dinamik boleh disepadukan dengan cara ini Kecekapan operasi yang tinggi, digabungkan dengan kecekapan tinggi pembangunan bahasa dinamik, membuatkan saya teruja hanya memikirkannya (melarikan diri.

package main
// ...
func CheckGlobal(proto *lua.FunctionProto) error {
for _, code := range proto.Code {
switch opGetOpCode(code) {
case lua.OP_GETGLOBAL:
return errors.New("not allow to access global")
case lua.OP_SETGLOBAL:
return errors.New("not allow to set global")
}
}
// 对嵌套函数进行全局变量的检查
for _, nestedProto := range proto.FunctionPrototypes {
if err := CheckGlobal(nestedProto); err != nil {
return err
}
}
return nil
}
func TestCheckGetGlobal(t *testing.T) {
l := lua.NewState()
proto, _ := CompileString(`print(_G)`)
if err := CheckGlobal(proto); err == nil {
t.Fail()
}
l.Close()
}
func TestCheckSetGlobal(t *testing.T) {
l := lua.NewState()
proto, _ := CompileString(`_G = {}`)
if err := CheckGlobal(proto); err == nil {
t.Fail()
}
l.Close()
}

Setelah sekian lama mencari dalam talian, saya mendapati tiada perkongsian teknikal tentang Go-Lua, saya hanya menjumpai artikel yang sedikit berkaitan (Pengoptimuman Senibina Berterusan Halaman Senarai Peringkat Ketiga JD.com—Golang Lua (OpenResty). Amalan Terbaik). Dan dalam artikel ini, Lua masih berjalan pada C. Disebabkan kekurangan maklumat dan kekurangan pengalaman pembangunan saya (pihak pelajar), saya tidak dapat menilai dengan baik kebolehlaksanaan penyelesaian ini dalam pengeluaran sebenar. Oleh itu, artikel ini hanya boleh dianggap sebagai "artikel santai", haha.

Atas ialah kandungan terperinci Apakah percikan api yang akan timbul apabila Golang dan Lua bertemu?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!