시부가와 씨가 쓴 Go라면 시스템 프로그래밍을 알아볼 수 있어서 기뻐서 저도 한번 해봤어요.
자신의 필기를 하다.

고라면 다 아는 시스템 프로그래밍.

Go 언어와 시스템 호출 사이에는 C++가 없기 때문에 Go로 낮은 수준을 이해할 수 있다.이거 재미있다.그리고 디버거로 안쪽 코드를 보고 시스템 호출까지 쫓아다니며 해설하다니 정말 멋지네요.책을 사고 싶지만 물리책이라서 귀국해서 사볼게요.

디버거 설정

이 연재의 중점은 원고이기 때문에 준비해 보아야 한다.IntelliJ를 사용하지 않았기 때문에 Visual Studio Code를 사용하여 동일한 설정을 했습니다.이것은 매우 간단하다.VScode에서 다음 장소로 디버거를 설정합니다.


틀만 있으면 돼.내 이름은 바뀌었을 뿐이야.
launch.json

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
    {
        "name": "Go Launch file",
        "type": "go",
        "request": "launch",
        "mode": "debug",
        "program": "${file}"
    },
        {
            "name": "Launch",
            "type": "go",
            "request": "launch",
            "mode": "debug",
            "remotePath": "",
            "port": 2345,
            "host": "127.0.0.1",
            "program": "${fileDirname}",
            "env": {},
            "args": [],
            "showLog": true
        }
    ]
}

연재를 즐기는 재미만 남았습니다.

낮은 수준의 접속으로 통하는 입구(1):io.Writer

실제로 디버거를 돌려보면 인터페이스가 달라지지만, 중요한 것에 집중해 이해하면 다시 읽을 수 있겠죠.기본적으로 변하지 않다.
첫 번째 에서는 파일 설명자를 설명합니다.Go의 경우 (f *File)io.Write(b []byte) (n int, err error)의 인터페이스가 같으면 다각형과 유사할 수 있다.
OS 수준에서 파일 설명자는 파일뿐만 아니라 비표준 출력, 소켓, 임의 수 등의 파일도 처리할 수 있다.따라서 OS의 차이를 숨기기 위해 파일 설명자를 나타내는 구조체를 만들어 조작을 통해 OS의 차이를 흡수한다.
Write 메서드(예: File이 아닌 FD) 구조체.
fd_unix.go

func (fd *FD) Write(p []byte) (int, error) {
    if err := fd.writeLock(); err != nil {
        return 0, err
    }
    defer fd.writeUnlock()
    if err := fd.pd.prepareWrite(fd.isFile); err != nil {
        return 0, err
    }
    var nn int
    for {
        max := len(p)
        if fd.IsStream && max-nn > maxRW {
            max = nn + maxRW
        }
        n, err := syscall.Write(fd.Sysfd, p[nn:max])
        if n > 0 {
            nn += n
        }
        if nn == len(p) {
            return nn, err
        }
        if err == syscall.EAGAIN && fd.pd.pollable() {
            if err = fd.pd.waitWrite(fd.isFile); err == nil {
                continue
            }
        }
        if err != nil {
            return nn, err
        }
        if n == 0 {
            return nn, io.ErrUnexpectedEOF
        }
    }
}

파일의 FD 정의입니다.파일 설명자는 숫자인 것 같습니다. 이외에도 정보 보호가 있습니다.

type FD struct {
    // Lock sysfd and serialize access to Read and Write methods.
    fdmu fdMutex

    // System file descriptor. Immutable until Close.
    Sysfd int

    // I/O poller.
    pd pollDesc

    // Writev cache.
    iovecs *[]syscall.Iovec

    // Whether this is a streaming descriptor, as opposed to a
    // packet-based descriptor like a UDP socket. Immutable.
    IsStream bool

    // Whether a zero byte read indicates EOF. This is false for a
    // message based socket connection.
    ZeroReadIsEOF bool

    // Whether this is a file rather than a network socket.
    isFile bool
}

File Descriptor

integer value
file stream
0
stdin
1
stdout
2
stderr
이후 이번 보도에서는 다양한 방법io.Write이 시행된다.파일, http 버퍼링, 서버, gzip 압축 등 장식 도안이 생각납니다.버퍼가 있는 기능은Flush()인데 Go는 버퍼링 없이 갑자기 시스템 호출을 하는 방식이지만 성능에는 문제가 없다.

샘플 프로그램

그러면 베껴 쓰면서 재미있는 기사를 읽고, 선생님의 가르침에 따라 자신도 간단한 실복을 만들어 보았습니다.실시해 보았다io.Write.자세한 설명은 없지만 알파벳 암호화 라이터 w

package main

import (
    "fmt"
    "io"
    "os"
)

type asciiEncryptWriter struct {
    w io.Writer
}

func (ew *asciiEncryptWriter) Write(p []byte) (int, error) {
    var b [1]byte
    r := 0
    for n, _ := range p {
        b[0] = p[n]
        if ('a' <= b[0] && b[0] <= 'z') || ('A' <= b[0] && b[0] <= 'Z') {
            if b[0] == 'z' {
                b[0] = 'a'
            }
            if b[0] == 'Z' {
                b[0] = 'A'
            }
            b[0]++
        }
        nw, err := ew.w.Write(b[:])
        if err != nil {
            return nw, err
        }
    }
    return r, nil
}

// NewASCIIEncryptWriter provide  super strong word encryption.
func NewASCIIEncryptWriter(w io.Writer) *asciiEncryptWriter {
    return &asciiEncryptWriter{w}
}

func main() {
    w := NewASCIIEncryptWriter(os.Stdout)
    fmt.Fprintln(w, "Very Strong Encryption")
}

실행

Wfsz Tuspoh Fodszqujpo

이것은 재미있는 연재다.나는 프로그래밍의 즐거움이 생각났다.앞으로의 내용이 무척 기대된다.