効率的なGoから私が学んだこと

package main

// 標準ライブラリからのインポート
import (
    "fmt"
    "os"
)

// 外部パッケージからのインポート
import (
    "github.com/gin-gonic/gin"
    "golang.org/x/net/context"
)

package main

import (
    "fmt"
    "os"
)

func main() {
    _, err := os.Open("filename.txt")
    if err != nil {
        fmt.Println("エラーが発生しました:", err)
        return // エラーがある場合はここで処理を終了
    }

    // ファイル操作など、エラーがない場合の処理を続ける
    fmt.Println("ファイルを正常に開きました。")
}

package main

import "fmt"

// Animal interface
type Animal interface {
 Describe()
}

type Cat struct {
 Name string
}

// AnimalInterfaceに定義されているメソッドを実装していればAnimalInterfaceとしてみなされる
func (c Cat) Describe() {
 fmt.Printf("This is %s, a cat.\n", c.Name)
}

// Dog struct
type Dog struct {
 Name  string
 Breed string
}

func (d Dog) Describe() {
 fmt.Printf("This is %s, and it is a %s.\n", d.Name, d.Breed)
}

func main() {
 animals := []Animal{
  Cat{Name: "Whiskers"},
  Dog{Name: "Rex", Breed: "Golden Retriever"},
 }

 for _, animal := range animals {
  animal.Describe()
 }
}

flowchart LR
    A[新しい問題報告] --> B{同様の問題？}
    B -- はい --> C[過去問題に誘導]
    C --> D[問題Close]
    D --> E[完了]
    B -- いいえ --> F{利用状況はサポート外？}
    F -- はい --> G[やんわり指摘]
    G --> H{リソース消費は効率的？}
    H -- はい --> D
    H -- いいえ --> I[問題報告し情報確認、対応策とアイデア検討]
    I --> D
    F -- いいえ --> I

システム
┌───────────────────────┐
│       モジュール        │
│ ┌─────────────────────┤
│ │アルゴリズムとデータ構造 │
│ ├─────────────────────┤
│ │   実装 | コンパイラー  │
│ ├─────────────────────┤
│ │オペレーティングシステム │
│ ├─────────────────────┤
│ │     ハードウェア      │
└───────────────────────┘

graph TD
    A[開始]
    B[テスト/評価]
    C{機能要件を全て満たしているか？}
    D[ベンチマーク/評価]
    E[設計・実装・修正]
    F{性能要件を全て満たしているか？}
    G[ボトルネックの発見]
    H[レベルの選択]
    I[最適化]
    K[リリース]

    subgraph 機能フェーズ
        A --> B
        B --> C
        C -->|No| E
        E --> A
    end

    subgraph 効率化フェーズ
        C -->|Yes| D
        D --> F
        F -->|No| G
        G --> H
        H --> I
        I --> B
    end

    subgraph リリースフェーズ
        F -->|Yes| K
    end

          CPU
┌──────────────────────────────────┐
│  ┌─────────────────┐┌────┐┌────┐ │ 
│  │┌───────┐ ┌───┐  ││CPU ││CPU │ │ 
│  ││レジスタ│ │ L1│  │└────┘└────┘  │ 
│  │└───────┘ └───┘  │┌────┐┌────┐ │ 
│  │┌──────────┐┌───┐││CPU ││CPU │ │ 
│  ││コントロール││L2 ││└────┘└────┘ │ 
│  ││ユニット   │└───┘ │            │
│  │└──────────┘┌───┐│┌──────────┐ │
│  │            │ALU│││L3キャッシュ│ │ 
│  │            └───┘│└──────────┘ │ 
│  └─────────────────┘             │
└──────────────────────────────────┘
   │（USB/SATA/PCI-E）   |
 IOデバイス            メモリコントローラー
                               |
                              RAM

go mod init example.com/compile
touch sum.go
touch sum_test.go
go test -c
go tool objdump -S complie.test > sum_asm.s

package main

import "fmt"

// 数値の配列を合計する関数
func Sum(numbers []int) int {
 total := 0
 for _, number := range numbers {
  total += number
 }
 return total
}

func main() {
 // 配列を定義
 numbers := []int{11, 13, 17, 19, 23}

 // Sum関数を呼び出し
 result := Sum(numbers)

 // 結果を表示
 fmt.Println("Sum:", result)
}

package main

import "testing"

func TestSum(t *testing.T) {
 numbers := []int{1, 2}
 result := Sum(numbers)
 expected := 3
 if result != expected {
  t.Errorf("Sum(1, 2) = %d; want %d", result, expected)
 }
}

func anotherFunction(arg1 string) { /*...*/ }

func function() {
    // ① ...
    go func() {
        // ② ...
    }()

    go anotherFunction("argument1") ③

    return ④
}

func sharingWithChannel() (sum int64) {
    result := make(chan int64) ①

    concurrentFn := func() {
        // ...
        result <- randInt64() ②
    }

    go concurrentFn()
    go concurrentFn()
    go concurrentFn()

    for i := 0; i < 3; i++ {
        sum += <-result ④
    }

    close(result) ⑤
    return sum
}

$ ./run_and_check.sh
  PID      VSZ    RSS COMM
42511 410075680   1120 go
  PID      VSZ    RSS COMM
42511 411371984  21696 go

package main

import (
 "fmt"
 "os"

 "github.com/efficientgo/core/merrors"
 "golang.org/x/sys/unix"
)

type MemoryMap struct {
 f *os.File // 匿名なら nil
 b []byte
}

// OpenFileBacked は、指定されたパスからファイルによってバックアップされたメモリマップを作成します。
func OpenFileBacked(path string, size int) (*MemoryMap, error) {
 f, err := os.OpenFile(path, os.O_RDWR, 0644)
 if err != nil {
  return nil, err
 }

 b, err := unix.Mmap(int(f.Fd()), 0, size, unix.PROT_READ|unix.PROT_WRITE, unix.MAP_SHARED)
 if err != nil {
  return nil, merrors.New(f.Close(), err).Err()
 }

 return &MemoryMap{f: f, b: b}, nil
}

// Close はメモリマップを解除し、ファイルを閉じます。
func (m *MemoryMap) Close() error {
 errs := merrors.New()
 errs.Add(unix.Munmap(m.b))
 errs.Add(m.f.Close())
 return errs.Err()
}

// Bytes はメモリマップされたバイト配列を返します。
func (m *MemoryMap) Bytes() []byte { return m.b }

func main() {
 // テスト用のファイルパスとサイズ
 path := "test1mbfile.out"
 size := 1 * 1024 * 1024 // 1MB

 // メモリマップを作成
 mm, err := OpenFileBacked(path, size)
 if err != nil {
  fmt.Println("Error opening file:", err)
  return
 }
 defer func() {
  if err := mm.Close(); err != nil {
   fmt.Println("Error closing memory map:", err)
  }
 }()

 // メモリマップされたデータにアクセス
 fmt.Println("Before modification:")
 fmt.Println("Reading the 5000th byte:", mm.Bytes()[5000])
 fmt.Println("Reading the 100 000th byte:", mm.Bytes()[100000])
 fmt.Println("Reading the 104 000th byte:", mm.Bytes()[104000])

 // メモリマップされたデータを書き換え
 mm.Bytes()[5000] = 'A'
 mm.Bytes()[100000] = 'B'
 mm.Bytes()[104000] = 'C'

 fmt.Println("After modification:")
 fmt.Println("Reading the 5000th byte:", mm.Bytes()[5000])
 fmt.Println("Reading the 100 000th byte:", mm.Bytes()[100000])
 fmt.Println("Reading the 104 000th byte:", mm.Bytes()[104000])
}

package main

import (
 "fmt"
 "os"
)

func main() {
 // 600MBのファイルを開く
 f, err := os.Open("test68mbfile.out")
 if err != nil {
  fmt.Println("Error opening file:", err)
  return
 }
 defer f.Close()

 // 600MBのバッファを作成
 b := make([]byte, 600*1024*1024)

 // ファイルからバッファにデータを読み込む
 if _, err := f.Read(b); err != nil {
  fmt.Println("Error reading file:", err)
  return
 }

 // バッファ内の特定の位置のデータを表示
 fmt.Println("Reading the 5000th byte:", b[5000])
 fmt.Println("Reading the 100 000th byte:", b[100000])
 fmt.Println("Reading the 104 000th byte:", b[104000])
}

関連記事

• Go言語「log/slog」パッケージの日本語翻訳
  
• Hiding nil values in Go: Understanding Why Go Fails Here
  
• 自分用go-playgroundのドキュメント必要そうな部分だけ日本語にした
  
• the Go compilerのドキュメントを日本語翻訳
  
• EC2で動かしていたアプリケーションが突然動かなくなった時の話
  
• メモリ使用量が減った!? その理由はSwapファイルでした