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 WorldDari 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 perlufunc (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)
// ...
}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.328sPanggilan 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.467sPencemaran 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
// gomoduleDalam 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)
}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!
Bagaimana untuk menentukan pembolehubah dalam golang
Apakah kaedah penukaran data dalam golang?
Apakah perpustakaan yang biasa digunakan di golang?
Apakah perbezaan antara golang dan ular sawa
Bagaimana untuk menjana nombor rawak dalam js
Bagaimana untuk menyelesaikan tamat masa
Adakah inskripsi Bitcoin akan hilang?
Bagaimana untuk menutup port 135
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
