GoSuda

Go syscall е превъзходен заместител на I/O на ниско ниво

By Yunjin Lee
views ...

Резюме

Ще научим за директното системно извикване в Go. Тъй като Go предлага стриктни грешки на компилатора и строг GC, е много по-добре да се заменят нисконивовите извиквания в Pure Go. За щастие, повечето от извикванията на C функции са напълно преимплементирани в Go, по добър и съвременен начин. Нека разгледаме това.

Системно Извикване

Системното извикване е директна заявка към операционната система. Тъй като системата обикновено е написана в строг, старомоден стил, тъй като работи директно върху хардуер, трябва да вземем предвид, че нейното извикване трябва да предостави стриктна и коректна форма на заявка. Така че, дори ако не се нуждаем от някои променливи, пак трябва да попълним размера, независимо от употребата. Нека проверим с напълно работещ пример.

Пълен Пример

 1package main
 2import (
 3	"fmt"
 4	"syscall"
 5	"unsafe"
 6)
 7
 8type sysinfo_t struct {
 9	Uptime    int64
10	Loads     [3]uint64
11	Totalram  uint64
12	Freeram   uint64
13	Sharedram uint64
14	Bufferram uint64
15	Totalswap uint64
16	Freeswap  uint64
17	Procs     uint16
18	Pad       uint16
19	_         [4]byte
20	Totalhigh uint64
21	Freehigh  uint64
22	MemUnit   uint32
23	_         [4]byte
24}
25
26func main() {
27	var info sysinfo_t
28	_, _, errno := syscall.Syscall(syscall.SYS_SYSINFO, uintptr(unsafe.Pointer(&info)), 0, 0)
29	if errno != 0 {
30		fmt.Println("sysinfo syscall failed:", errno)
31		return
32	}
33
34	scale := float64(1 << 16)
35	fmt.Printf("Uptime: %d seconds\n", info.Uptime)
36	fmt.Printf("Load Average: %.2f %.2f %.2f\n",
37		float64(info.Loads[0])/scale,
38		float64(info.Loads[1])/scale,
39		float64(info.Loads[2])/scale)
40	fmt.Printf("Memory: total=%d MB free=%d MB buffer=%d MB\n",
41		info.Totalram*uint64(info.MemUnit)/1024/1024,
42		info.Freeram*uint64(info.MemUnit)/1024/1024,
43		info.Bufferram*uint64(info.MemUnit)/1024/1024)
44	fmt.Printf("Swap: total=%d MB free=%d MB\n",
45		info.Totalswap*uint64(info.MemUnit)/1024/1024,
46		info.Freeswap*uint64(info.MemUnit)/1024/1024)
47	fmt.Printf("Processes: %d\n", info.Procs)
48}

Този пример включва всички променливи и отпечатва обширна информация за текущата системна информация. Можем да сравним този код като шкафче и ключ.syscall.SYS_SYSINFO е ключ, който отключва шкафче, което се намира вътре в ядрото. Следователно, използването на коректен ключ за шкафчето е важно. Какво ще се случи, ако използваме syscall.SYS_GETPID за това извикване? Това е ключ за шкафче, което съдържа Process ID. Това ще се опита да получи PID от пространството за системна информация. В резултат на това, никоя от информациите не може да бъде прочетена коректно; извикването трябва да бъде върнато като неуспешно състояние.

Сега трябва да знаем кои елементи се съдържат и как са подредени елементите. В първия слот на шкафчето имаме Uptime, с размер 2^64. Ако се опитаме да прочетем това с 2^32, бинарната последователност не е напълно прочетена. Не можем да използваме такива частични двоични данни, освен ако няма да пишем нисконивови трикове.

След прочитане на 64 бита двоични данни, най-накрая сме на втория слот. Той може да бъде прочетен точно само когато сме прочели предходното цяло число с размер 64 бита.

Чрез повтаряне на тези стриктни и логически потоци за получаване на подходяща информация от системата, можем правилно да обработим прочетените данни.

Как да пропуснем 'имена на променливи'

Въпреки че не можем да 'пропуснем' самите променливи, важно е да се прави разлика между използваните променливи и изхвърлените. Ако употребата на програмата е достатъчно ясна, е по-добре да се използват безименни променливи като заместители, отколкото да се етикетират всяка стойност, дори ако те никога няма да бъдат използвани. Нека проверим това с пример, "Проверка на свободната памет"

Пример - Проверка на свободната памет

Когато проверяваме Свободна Памет/Swaps, не се нуждаем от друга информация, която показва различни ресурси. За да постигнете по-добра видимост, можете да създадете анонимни променливи, които да държат специфични пространства.

 1package main
 2
 3import (
 4	"fmt"
 5	"syscall"
 6	"unsafe"
 7)
 8
 9type sysinfo_t struct {
10	_          int64
11	_         [3]uint64
12	Totalram  uint64
13	Freeram   uint64
14	Sharedram uint64
15	Bufferram uint64
16	Totalswap uint64
17	Freeswap  uint64
18	_         uint16  // anonymous, and unused ones are marked as _ (анонимните и неизползвани са маркирани като _)
19	_         uint16  
20	_         [4]byte 
21	_         uint64  
22	_         uint64  
23	MemUnit   uint32
24	_         [4]byte
25}
26
27func main() {
28	var info sysinfo_t
29	_, _, errno := syscall.Syscall(syscall.SYS_SYSINFO, uintptr(unsafe.Pointer(&info)), 0, 0)
30	if errno != 0 {
31		fmt.Println("sysinfo syscall failed:", errno)
32		return
33	}
34
35	fmt.Printf("Memory: total=%d MB free=%d MB buffer=%d MB\n",
36		info.Totalram*uint64(info.MemUnit)/1024/1024,
37		info.Freeram*uint64(info.MemUnit)/1024/1024,
38		info.Bufferram*uint64(info.MemUnit)/1024/1024)
39	fmt.Printf("Swap: total=%d MB free=%d MB\n",
40		info.Totalswap*uint64(info.MemUnit)/1024/1024,
41		info.Freeswap*uint64(info.MemUnit)/1024/1024)
42}

Следователно, променливите се четат без етикети. Въпреки че анонимните стойности всъщност се съхраняват в структура, няма етикети/четими маркировки в кода.

Заключение

  • Използването на syscall и unsafe на Go все още е по-безопасно от C/CGo
  • Ако пишете голям проект, който може лесно да бъде разширен:
    • Не създавайте анонимни променливи; създайте имена за всеки член.
  • Ако пишете проект, който има ограничена употреба:
    • Можете да използвате анонимни променливи, за да държите пространства, които всъщност са неизползвани.
  • syscall на Go е мощен и модерен за обработка на нисконивови извиквания

Прочетете Още

syscall unsafe x/sys/unix