ラベル golang の投稿を表示しています。 すべての投稿を表示
ラベル golang の投稿を表示しています。 すべての投稿を表示

2024年1月14日

スタックメモリとヒープメモリの使い分けはコンパイラ任せ (1)

golang は chan で時空を超えて(?)値を渡すことができる。

といっても、golang って C言語になかなか近いところがあるので、ポインタで渡すときはヒープにメモリを確保しておかないと危ないよね?
と思って new なり make なり使うべきかと考えていたのだが、ガベッジコレクションもあることを考えるとそう簡単ではない気がした。

 

心配になって検索すると、どうも golang ではスタックメモリやらヒープメモリやらを実装する人が決められないというか、コンパイラが決定するというような記事ばかりが出てくる。

https://duckduckgo.com/?t=ffab&q=golang+stack+heap&ia=web

ただ、そうするとかなりな部分がヒープメモリで管理することになってしまうんじゃなかろうか。いや、関数呼び出しで値がプリミティブだったらスタックにする、みたいなところだけやっておけば十分なのか?

 

よし、忘れよう。

ならば実装する人が気にするのは、値そのものを持つのか、あるいはアドレスで持つのかというところだけになる。
まず、値をリードオンリーで済ませられるかどうか。

  • 値を渡した先でも加工する可能性がある
    • 渡した先でも加工する可能性があるのであれば、それは値そのものを渡す必要がある。
    • 渡した先は参照だけだが、渡された瞬間の値だけがほしいのであれば、それも値そのものを渡した方がよいだろう。アドレスを渡して渡された先がそれを自分でコピーする前に渡した元が加工する可能性があるからだ。
    • 渡した先は参照だけで、渡された元の値の変化も含めて読みたい場合。これならアドレスを渡せばいいと思ったのだけど、そもそも同じメモリ空間をロックせずに読んだり書いたりするというのはダメな行為だ。
  • 値を渡した先は参照のみ
    • 渡した元で値を加工する可能性があるなら、やっぱりアドレスを渡すのは良くないな。

というわけで、プリミティブ型であれば値をそのまま渡してしまえば良いとは思うのだが、CPUのバス幅を超えるようなデータの場合はちょっと考えた方がよいと思う。

 

調べる前に推測してみよう。

chan で渡すデータはアドレスがよいと思う。
なぜなら、値を渡すという行為は何らかのコピーになるのでコストが高いからだ。加工する可能性があるならばchan で渡す前にコピーを作って chan ではコピーしたメモリのアドレスを渡すべきだろう。
コンパイラが賢そうなので、実装する人がそういうのを考慮しなくてもよいのかもしれないが、たぶんそこは実装されたままコンパイルされるんじゃなかろうか。言語仕様としてアドレスにする&があるのだから、そうでなかったらコピーして渡しそうな気はする。ただまあ、それでも実装としてコピーするかコンパイラがコピーするかの違いになるから、あんまり変わらないか、もしかしたら明示的に書いたので最適化できずにコストが高くなってしまう可能性もあるのか...。

さて、推測はした。
答え合わせをしよう。


同じメモリを読み書きするとなると、どうしてもロック・アンロックの機構は必要になる。

どういう単位でアクセスするコンテキストが切り替わるかはわからないが、100バイトあるデータの内50バイト書き換えたタイミングでコンテキストが切り替わる、なんてことも想定しないといかんだろう。
golangではない普通のスレッドモデルで実装していたときだが、32bit の CPU だったのに日付(RTC)を 64bit で持っていて、ごく希に 32bit だけ書き換えたタイミングでコンテキストが切り替わることがあってデータが以上になるということが発生したことがある。あれは痛恨のミスだった。

だから、golang が chan でデータを送りつけるモデルを持つというのはわかりやすかった。
相手が読み取りタイミングで読み取ってほしいけど、こっちはこっちでそのタイミングを気にしたくないということは多いのだ。さっき書いた時刻も getTime() みたいな API を作ってたのでこうなったが、相手が送ってきた最後のデータをこちらが好きなタイミングで読む、だったら問題は少ない。相手が送ってきたデータをこちらが受け取るタイミングと、そのデータをこちらが読み込むタイミングがあるので、そこを共有メモリで実現するなら mutex などでロックする必要がある。が、chan はそういうことがいらないようになっているので現場レベルでは気にしなくてよい。たぶん。

 

そう考えると、chan で渡すデータについては glang でうまいことやってくれるとしても、そこから先は golang がやってくっるとは思えない。
いや、それは私の理解であって golang が実際どうなのかはまだわかっていない。

時間が足りないので次回にしよう。

2024年1月8日

golangの無名関数

私が一番なじんでいる開発言語はC言語だ。
今後は変わるかもしれないが、まだ一番だ。

二番をgolangにしようとしている。まあ、C++歴もまあまあ長いのだがしばらく使っていないし、それ以外の言語も C言語っぽいから使えているという程度のように思っている。
golang も C言語っぽい。例外がなかったり、*や&を使ったりするなどバイナリになったときのイメージが C言語に近いのもよろしい。

私が golang を覚えるときは C言語と同じだったり違いだったりという差分でやろうとしている。全部覚えられるほど記憶がよくはないのだよ。。。
golang は新しい言語なので、新しい(というわけでもないだろうが)仕様がある。


Javaにもあったと思うのでそんなに新しい言語仕様ではないと思うのだが、C言語自体にはなかったはずである。型として関数を指定できるという意味では関数ポインタに近いような感じはするのだが、イコールとまではいかない。

関数の引数に func(xxx) があるとする。それだけなら関数ポインタと同じだと思う。C言語でも 同じシグネイチャの関数であれば引数に指定できるからだ。しかしそれは無名関数の機能?ではなく、単に引数として func が使えるというだけだろう。

では func をどうやって定義するかというと、ここら辺が golang の特徴ということになるだろうか。

  • グローバルの func
  • 関数の戻り値の func
  • 無名関数の func

 関数を戻り値として返すことができるということで2番目と3番目は分けたが、C言語では関数を戻り値にできなかったはずだから別にした。いや、たぶん関数ポインタとして返すことはできるのだが、関数そのものを返すということはできないはずだ。そういう意味では3番目も同じく、C言語で関数名のない関数を定義することはできなかったはずだ。

defer に直接 func で中身を書くことができたりするのは無名関数があるからだろう。局所的に関数を設定できるのは便利といえば便利だ。ローカル変数を引数で渡さなくても済むし。


そう、ローカル変数を渡さなくて良いのだ。どういうしくみなんだろうか?
クロージャと呼ぶらしいので go.dev/spec を検索したがここしか出てこなかった。

Function literals
https://go.dev/ref/spec#Function_literals

function literals だったり anonymous function だったり closures だったり、よくわからんものが出てくる。

  • function literals は anonymous function として表される
  • function literals は closures である

anonymous function は「無名関数」のこと。匿名関数と書いてあることもあるがまあいい。名前がないので特定できないから匿名だ、と思っておけば良いだろう。

function literals は「関数リテラル」だ(そのまま)。関数を値にしたものとでも思っておけば良いだろう。ということは、名前がある関数は関数リテラルにはならないということか。
しかし、関数を引数にすることはできるので、名前がある関数でも関数値にはできるはずだ。一般的に「関数を表す式」のことを関数リテラルと呼び、いろいろ言語実装があるのだがたいていの言語では無名関数を呼び出したかったら式にするしかないので、無名関数は関数リテラルが同じものになったということだろう。

クロージャは、関数周辺で定義された変数を参照できる、と書いてある。defer で func() を直接書いて、その中にクローズする処理なんかを書くことができるのもクロージャだからだろうが、全然意識したことがなかった。defer だからスコープが関数の中で閉じてるし、そういうものだと思っていたのだ。

が、これは func() を返す関数でも同じことで、返す関数の中でローカル変数を参照していたとしても、それを含めて扱ってくれる。

https://go.dev/play/p/eoGL5r405rI
package main

import "fmt"

func count() func() uint8 {
	var cnt uint8
	return func() uint8 {
		cnt++
		return cnt
	}
}

func main() {
	a := count()
	b := count()
	fmt.Printf("count A: %d\n", a())
	fmt.Printf("count B: %d\n", b())
	fmt.Printf("count A: %d\n", a())
	fmt.Printf("count A: %d\n", a())
	fmt.Printf("count B: %d\n", b())
}


a と b それぞれで cnt を別々に保持してくれるので、外部でグローバル変数を用意して渡す、みたいなことをしなくてよい。不安になってしまうのだが、これは慣れるしかないだろう。

2023年12月24日

golang の取りあえず context

居酒屋に入って「取りあえずビール(中ジョッキ)」とやってしまうような感覚で、golang の引数に context があったら、上位から渡されたのがあればそれを、なければ context.Background() で与えていることが多い。

もう少し調べておこう。

 

まず、context.Background() はこれだ。

https://cs.opensource.google/go/go/+/release-branch.go1.21:src/context/context.go;l=211-213

backgroundCtx{} を返すだけで、NewBackgroundCtx() という名前にしたい気もするが、これはアドレスではなくインスタンスを返すから new が付かないのだろうか。
その下に context.TODO() もある。同じようにを todoCtx{} 返すだけである。

標準の context.Context はいくつあるのだろう?

目視なのでとりこぼしがあるかもしれない。

サンプルでよく見る context.Background() と context.TODO() だが、どちらも emptyCtx を組み込んだだけになっている。

context.Background() は「これで contextを始める!」という top-level の場合に使い、context.TODO() は「まだよくわからんけどこれでやっておこう」という unclear なときに使う。

cancelCtx は、名前からするとキャンセルを通知できるようになっているのだろう。
じゃあ withoutCancelCtx は? emptyCtx との違いは Value() があるくらいだろうか。cancelCtx を使っていたけどキャンセル機構をなくしたくなった場合とか?
いや、cancelCtx を直接作る関数は用意されていない(引数にcontextを取る)から扱いが違うんだろうか。

 

だいたい、なんで Background() などは type Context の下にあるのだろう? レシーバーがあれば Types の下になるのは分かるのだが、戻り値が1つでそれが type だったら Types の下にぶら下がるんだろうか。

 こんなはっきりしない終わり方は嫌なので、ちゃんと context について説明しているサイトを読もう(この記事台無し......)!

よくわかるcontextの使い方
https://zenn.dev/hsaki/books/golang-context

 

2023年12月16日

golang の test で before each は(たぶん)ない

golang でテストを書く場合、 TestMain(*testing.M) があるとそのファイルの中に *testing.T の関数は呼ばずに TestMain() だけ呼び出し、その中で Run() を呼び出すことで *testing.T の関数が呼ばれるらしい。
それを利用して、テスト全体の事前処理と事後処理を書くと良いそうだ。

ならば、各*testing.T の関数を呼び出す前後にも単独の事前処理と事後処理を呼び出すしくみがありそうなものだが、どうも無いようだ。

しくみを作っている人もいそうではあったが、標準にないならいいかな、と私は思った。テスト関数に直接埋め込むだけだ。
埋め込み忘れるという心配はあるのだが、だいたい TableDrivenTests とか言っているんだし、for文の中でテスト対象の関数を何度も呼び出すという書き方をすることが多いのだとすると、テスト関数単独の事前/事後処理を呼び出してもなぁ、という気がする。

 

 

golangのtestは自由度が高すぎる

golang は標準で testing というパッケージを持っていて、テストコードを書いたり、テストコードは実行ファイルに含めないようになっていたりとテスト用のしくみがある。

それはよいのだが、自由度が高すぎると思う。ファイルや関数の決まり事以外は t.Errorf()を通ればエラー、というだけのルールだけなのでどのようにでも書けてしまう。私はテストする関数と、あとは結果が正常系だったりエラーのxxだったりみたいな感じでテスト関数を分けて書いたりしていたが、境界値テストみたいな場合は構造体で INPUT と期待する OUTPUT の組を作った配列を for でぐるぐる回したりして、今ひとつ統一性がなかった。

 

go.dev の wiki には TableDrivenTests という項目があった。さっき最後に書いた構造体でテストデータと結果を作って流すような書き方がこれのようだ。

TableDrivenTests - The Go Programming Language
https://go.dev/wiki/TableDrivenTests

この方式だけでテストが書けるならば、テスト対象の関数とテスト関数が同じ数だけ並ぶので、わかりやすいと思う。
ただねー、INPUT と OUTPUT 以外に「前提条件」もあることが多いではないか。あれを構造体だけで表すのが難しいこともあると思うのだよ。
と思ったが、関数分けして書いたとしても前提条件を実装しないといけないことに変わりは無いので、それを「前提条件1」「前提条件2」みたいな INPUT にして、それぞれを if 文で分岐してしまえば同じことなのか。あるいは構造体に func なメンバーを持ってしまえば良いのか。

 

などなど、go.dev に書いてある方式を使うことにしたとしてもまだ自由度が高いと思う。もうちょっと縛ってくれないだろうか。
こういうときはフレームワークだと思う。例えば JavaScript だとほぼ jest がデファクトスタンダードになっていると思うが、そういうやつ。

自分で探す気力が無かったので、記事を探した。

 testify がよく出てくるようだけど、デファクトスタンダードとまではいかないというところだろうか。

assert があるとテストの比較する部分の書き方が統一される。比較しているどちらが期待値でどちらが実際の値かということに頭を使いたくないのだ。mock はどのくらい使いやすいのかによるが、自分でモックのしくみを考えたくないのであるなら利用したい。

と、今回は紹介だけになった。気が向いたら次回試してみようと思うが、普通に使うなら本家のサンプルを見た方がわかりやすいだろう。

2023年12月2日

最近の go work

"go work" は比較的最近使えるようになった。
というと使いこなしているように見えてしまうが、実は初めて使う。。。

Tutorial: Getting started with multi-module workspaces
https://go.dev/doc/tutorial/workspaces

"go work" の "work" は workspace の work だろう。

このチュートリアルを最後まで行うと、workspace/ の中はこうなっている。赤枠がチュートリアルで作成した部分、それ以外は git clone で持ってきた部分だ。

 

hello.go で "fmt.Println(reverse.String("Hello"), reverse.Int(24601))

の reverse.Int(24601) はオリジナルの "golang.org/x/example/hello/reverse" にはなく、今回追加した int.go で実装されている。従来、こういう場合は go.mod の require にある "golang.org/x/example/hello/reverse" を replace で相対フォルダ指定して「実はこっち使ってます」宣言するのだが、"go work" のしくみを使うとそれが不要になっているというのがポイントだと思っている。

同じような使い方をするなら、誰かのリポジトリを GitHub fork して自前でちょっと変更したバージョンを使いたいとかだろうか。ただ fork すると別リポジトリとして扱いたいので git submodule で "go work" の中に配置するとかがよいのかな?

あるいは、単純に同じリポジトリの中に go.mod を複数持って相手を参照するような場合でも良いのか。gRPCサーバのアプリを作ったとき、protobuf の定義ファイルも同じリポジトリにおいたのだが、proto定義は変わらないのにサーバの更新だけ進むのでなんだかなー、という気持ちになっていた。
そういう場合にうまいこと使えないだろうかと考えたが、クライアントアプリも同じリポジトリで運用するならよさそうな気がする。気がするが、それは単に replace を書かなくていいのが便利なだけで gRPC の件とは何の関係もないな。

サーバのリポジトリの中に proto があると、クライアントアプリを作りたいだけなのに go.mod にサーバのパッケージを書くのでいらないものまでダウンロードすることになるというのがなんか嫌でね。どうせサーバもクライアントも同じPCで開発するだろうからいいやん、と言われればそれまでなのだが。

 

"workspace" という名前の通り、同じワークスペースにある go.mod はネットワーク参照ではなくローカル参照してくれるのが便利、という考え方で良いのかな。試作している間、repalce でローカルを読むように変更する手間が面倒だったので、workspace 自体は git 管理せずに作業中だけ使うというやり方でよいかもしれん。


最近の go get

"go get" の仕様が変わったという話は聞いていたし、実際に違いも感じるのだが、「なんとなく」で go get したり go mod tidy したりしている。
そのせいだと思うが、git clone してビルドするだけなのに go.mod が更新されていたり go.sum が更新されたりして落ち着かない。
それに過去の仕様を覚えているというわけでもない。

あきらめて、いまの go v1.21 くらいだとどう使うのが普通なのか調べておこう。


なるべく go.dev から参照していきたい。解説記事を読んだとしても、私が過去の仕様を知らないので「これは古い内容だ」という判断ができないのだ。

まず、go v1.17 から "go get" で実行ファイルのインストールが行われなくなった。
その代わりに "go install" を使いなさいということだ。

Deprecation of 'go get' for installing executables - The Go Programming Language
https://go.dev/doc/go-get-install-deprecation

その代わり "go get" がどうなったかというと、go v1.18 から go.mod への追加、更新、削除を行うようになったということだ。


今の "go get" の説明はここにあった。

go command - cmd/go - Go Packages
https://pkg.go.dev/cmd/go#hdr-Add_dependencies_to_current_module_and_install_them

"Add dependencies to current module and install them" というタイトルだったが、実際は更新や削除までやるようだ。
コマンド単体の説明があったので、こちらの方がよいか。

go get
https://go.dev/ref/mod#go-get

  • Upgrade a specific module.
  • Upgrade modules that provide packages imported by packages in the main module.
  • Upgrade or downgrade to a specific version of a module.
  • Update to the commit on the module's master branch.
  • Remove a dependency on a module and downgrade modules that require it to versions that don't require it.
  • Upgrade the minimum required Go version for the main module.
  • Upgrade the suggested Go toolchain, leaving the minimum Go version alone.
  • Upgrade to the latest patch release of the suggested Go toolchain.

多い、多いよ。。。

勝手に分類するなら、個別パッケージ向けかメインモジュール向けかというところか。

個別パッケージ向け

# Upgrade a specific module.
$ go get golang.org/x/net

# Upgrade or downgrade to a specific version of a module.
$ go get golang.org/x/text@v0.3.2

# Update to the commit on the module's master branch.
$ go get golang.org/x/text@master

# Remove a dependency on a module and downgrade modules that require it
# to versions that don't require it.
$ go get golang.org/x/text@none

# Upgrade to the latest patch release of the suggested Go toolchain.
$ go get toolchain@patch

メインモジュール向け

# Upgrade modules that provide packages imported by packages in the main module.
$ go get -u ./...

# Upgrade the minimum required Go version for the main module.
$ go get go

# Upgrade the suggested Go toolchain, leaving the minimum Go version alone.
$ go get toolchain


メインモジュールというのはカレントディレクトリか親ディレクトリの go.mod を指すそうだ。go.dev のドキュメントは "go get" や "go.mod" のフォントが若干他とは違っているようだけど、そのくらいだと見分けが付けづらいのよねぇ。

昔の "go get -d" が go v1.18 からはデフォルトの挙動になっている。"-d" がない場合はそのパッケージのビルドとインストールまでやっていた挙動がなくなったというのが仕様変更でよく言われている内容ということになる。

ここの用例ではオプションがあるけれども "go get" だけでも動作する。パッケージを指定していないのでメインモジュールに向けての操作になるはず。"-u" がないからアップグレードでもないし indirect な require だけ更新するのだろうか?


ここまで "go get" を見てきたが、パッケージの取得だけなら "go mod tidy" を使うイメージを持っている。が、 "go mod tidy" で go.sum が更新されたことがあるような気がするのだ。
なんとなく "go get" だけ実行したときと同じような感じがする。

go mod tidy
https://go.dev/ref/mod#go-mod-tidy

  • adds any missing module requirements necessary to build the current module’s packages and dependencies
  • removes requirements on modules that don’t provide any relevant packages.
  • It also adds any missing entries to go.sum and removes unnecessary entries.

こちらは go.modとソースコードの関係性を重視しているのか? "go get" は "-u" 指定しない限りは indirect くらいしか更新しないようだが "go mod tidy" は不要なパッケージがあれば indirect でなくても削除していた。ただ新しいバージョンがあっても更新はしないので、ビルドできるかどうかだけ判断しているのかな?

2023年11月25日

protoc-gen-go-grpcの-Mオプションがうまくいかない

gRPC の勉強というか仕事というか。

適当に proto ファイルを作って、protoc-gen-go と protoc-gen-go-grpc をインストールした状態で protoc を実行する。
が、エラーになった。

protoc-gen-go-grpc: unable to determine Go import path for "rpc.proto"

Please specify either:
       • a "go_package" option in the .proto source file, or
       • a "M" argument on the command line.

See https://developers.google.com/protocol-buffers/docs/reference/go-generated#package for more information.

--go-grpc_out: protoc-gen-go-grpc: Plugin failed with status code 1.

今回は自作した proto ファイルなので好きに編集できるが、別のところが提供している proto ファイルを使う場合は加工したくない。

なので --go_opt=M を付けて protoc を実行すると成功した。

2023年8月20日

golang: interfaceの勉強 (3)

続き。

hiro99ma blog: golang: interfaceの勉強 (2)
https://hiro99ma.blogspot.com/2023/08/golang-interface-2.html


struct と duck typing

golang の調べ物をしたとき、duck typing という言葉を見ることがある。
メソッド名・引数・戻り値が一致したら同じものと思われる、くらいに思っていたのでこういうことができると考えていた。

package main

import "fmt"

type Abc struct{}

func (a *Abc) Greet() {
    fmt.Println("Hello")
}

type Def struct{}

func (d *Def) Greet() {
    fmt.Println("Aloha")
}

func main() {
    abc := new(Abc)
    abc.Greet()
    abc = new(Def)
    abc.Greet()
}

これは赤文字のところでコンパイルエラーになる。コンパイルエラーというか文法エラーというか。

interface Ghi を作ってそこに Greet() を書いておき、使う場合は Ghi の変数として扱ってやると、Abc と Def が Ghi の派生であるとかを匂わせる必要もなく動くようになる。

package main

import "fmt"

type Ghi interface {
    Greet()
}

type Abc struct{}

func (a *Abc) Greet() {
    fmt.Println("Hello")
}

type Def struct{}

func (d *Def) Greet() {
    fmt.Println("Aloha")
}

func main() {
    var abc Ghi
    abc = new(Abc)
    abc.Greet()
    abc = new(Def)
    abc.Greet()
}

struct と interface を関連付けるような記述をしないというところが「プログラミング言語Go」のインターフェースの章で『暗黙的に満足される』といっている意味なんだろう。

暗黙的だと関連性がわからなくて悩みそうだと思ったなら、明示的に書いてもよいだろう。

type Abc struct{ Ghi }

明示的に interface があることを書いておきながらも、interface の方に定義されたメソッドを書いていない場合はコンパイルエラーになりそうだが、そうはならない。
どうなるかというと、未定義のメソッドを呼び出そうとした時点で実行時エラーになる。

panic: runtime error: invalid memory address or nil pointer dereference

package main

import "fmt"

type Ghi interface {
    Greet()
}

type Abc struct{ Ghi }

// func (a *Abc) Greet() {
//     fmt.Println("Hello")
// }

type Def struct{ Ghi }

func (d *Def) Greet() {
    fmt.Println("Aloha")
}

func main() {
    var abc Ghi
    abc = new(Abc)
    abc.Greet()
    abc = new(Def)
    abc.Greet()
}

goalng は全体的に縛り付けるような決まりが少ない気がする。その辺は C言語っぽいなーと感じる。

ともかく、golang は duck typing な言語なのかもしれないが(厳密な定義はよく知らない)、それは何でもかんでもじゃなくて interface が関係した場合だけなんだと思われる。


テストでinterfaceを使おうとする

mock なのか stub なのか driver なのか厳密なところ避けさせてもらう。
本物ではなく偽物にしたいということで fake という言葉を使おう。

テストで fake を使いたい場合、テストしたい関数なりメソッドなりは変更したくないのだが、その中で実際に行う処理は偽物に置き換えたいということだと思う。
ネットワークにアクセスする処理だがエラーを起こしたことにしてテストしたい、とか、ハードウェアにアクセスする処理だが実機では確認できないのでダミーの処理で置き換えたい、とか。

image

まず、テスト対象の関数/メソッドは、その中から呼び出す次の処理を切替ができるように書いておかないといかん。上の図だと黄色の丸で表しているが、これが golang でいうところの関数だったら切り替えるのは難しいだろう(タグで切り替えるということはできそうだが)。

ではメソッドの中から別のメソッドを呼ぶように書くとして、何をどう書くと良いだろう。

Golangにおけるinterfaceをつかったテストで mock を書く技法 - haya14busa
http://haya14busa.com/golang-how-to-write-mock-of-interface-for-testing/

こちらでは、対象となる方は interface を名前を付けて書いている。テスト対象自体が interface を所持しているのではなく外側にあって(所持してても良いだろうが)、new するときに設定しているのか。そして fake の方では interface を無名の埋め込みにしている。

 

ではもうちょっと簡易なコードにして試そう。
mocktest というディレクトリを作り、その中に main.go,  greet/greet.go, greet/machine.go というファイルを置く。

  • main.go
package main

import (
    "fmt"
    "mocktest/greet"
)

func main() {
    g := greet.NewGreet()
    g.SetData(3)
    fmt.Println(g.GetData())
}
  • greet/greet.go
package greet

type Greet struct {
    m     MachineInterface
    value int32
}

func NewGreet() *Greet {
    g := &Greet{}
    g.m = NewMachineData()
    return g
}

func (g *Greet) GetData() int32 {
    return g.value + g.m.Get()
}

func (g *Greet) SetData(value int32) {
    g.value = value
    g.m.Set(value)
}
  • greet/machine.go
package greet

import (
    "math/rand"
    "time"
)

type MachineInterface interface {
    Get() int32
    Set(value int32)
}

type MachineData struct {
    value int32

    r *rand.Rand
}

func NewMachineData() *MachineData {
    m := &MachineData{}
    m.r = rand.New(rand.NewSource(time.Now().UnixNano()))
    return m
}

func (m *MachineData) Get() int32 {
    multi := m.r.Int31n(100)
    return multi * m.value
}

func (m *MachineData) Set(value int32) {
    m.value = value
}

「go run .」などとして実行すると、毎回異なる値が出力されるだろう。
greet/machine.go が乱数を使っていて、ちょっとそのままではテストしづらいというようにしている。やっている内容として意味は無い。 greet/machine.go が制御できない動作をするということだけわかっていればよい。
ここでテストするならば greet/greet.go のメソッドになるし、fake にしたいのは greet/machine.go になる。

では適当にテストコードを書いてみる。

  • greet/greet_test.go
package greet

import (
    "testing"
)

type fakeMachineData struct {
    MachineInterface

    FakeGetData func() int32
    FakeSetData func(value int32)
}

func (f *fakeMachineData) Get() int32 {
    return f.FakeGetData()
}

func (f *fakeMachineData) Set(value int32) {
    f.FakeSetData(value)
}

func TestGetData1(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 10
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(3)
    value := mo.GetData()
    if value != 13 {
        t.Errorf("GetData: %v", value)
    }
}

func TestGetData2(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 15
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(5)
    value := mo.GetData()
    if value != 20 {
        t.Errorf("GetData: %v", value)
    }
}

$ go test ./greet/ -v
=== RUN   TestGetData1
--- PASS: TestGetData1 (0.00s)
=== RUN   TestGetData2
--- PASS: TestGetData2 (0.00s)
PASS
ok      mocktest/greet  0.001s

greet/greet_test.go は package が greet なので、小文字のフィールドにもアクセスできる。それを利用して greet.NewGreet() で設定している NewMachineData() を上書きしている。

 

greet/machine.go を別パッケージにしてみよう。
外部のライブラリを使っているとそうなるだろう。

  • greet/greet.go
package greet

import "mocktest/machine"

type Greet struct {
    m     machine.MachineInterface
    value int32
}

func NewGreet() *Greet {
    g := &Greet{}
    g.m = machine.NewMachineData()
    return g
}

func (g *Greet) GetData() int32 {
    return g.value + g.m.Get()
}

func (g *Greet) SetData(value int32) {
    g.value = value
    g.m.Set(value)
}
  • machine/machine.go
package machine

import (
    "math/rand"
    "time"
)

type MachineInterface interface {
    Get() int32
    Set(value int32)
}

type MachineData struct {
    value int32

    r *rand.Rand
}

func NewMachineData() *MachineData {
    m := &MachineData{}
    m.r = rand.New(rand.NewSource(time.Now().UnixNano()))
    return m
}

func (m *MachineData) Get() int32 {
    multi := m.r.Int31n(100)
    return multi * m.value
}

func (m *MachineData) Set(value int32) {
    m.value = value
}
  • greet/greet_test.go
package greet

import (
    "mocktest/machine"
    "testing"
)

type fakeMachineData struct {
    machine.MachineInterface

    FakeGetData func() int32
    FakeSetData func(value int32)
}

func (f *fakeMachineData) Get() int32 {
    return f.FakeGetData()
}

func (f *fakeMachineData) Set(value int32) {
    f.FakeSetData(value)
}

func TestGetData1(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 10
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(3)
    value := mo.GetData()
    if value != 13 {
        t.Errorf("GetData: %v", value)
    }
}

func TestGetData2(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 15
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(5)
    value := mo.GetData()
    if value != 20 {
        t.Errorf("GetData: %v", value)
    }
}

machine を import するようになるくらいの変更しかない。
外部のパッケージだったら interface があっても不自然ではない。

もしここで machine/machine.go に interface がなかったらどうしよう?
その場合は greet/greet.go の方で作っておけば良い。「暗黙的に満足される」から machine/machine.go は変更しなくても良いのだ。
案外、なんとかなるものだ。

  • macihne/machine.go
package machine

import (
    "math/rand"
    "time"
)

// type MachineInterface interface {
//     Get() int32
//     Set(value int32)
// }

type MachineData struct {
    value int32

    r *rand.Rand
}

func NewMachineData() *MachineData {
    m := &MachineData{}
    m.r = rand.New(rand.NewSource(time.Now().UnixNano()))
    return m
}

func (m *MachineData) Get() int32 {
    multi := m.r.Int31n(100)
    return multi * m.value
}

func (m *MachineData) Set(value int32) {
    m.value = value
}
  • greet/greet.go
package greet

import "mocktest/machine"

type MachineInterface interface {
    Get() int32
    Set(value int32)
}

type Greet struct {
    m     MachineInterface
    value int32
}

func NewGreet() *Greet {
    g := &Greet{}
    g.m = machine.NewMachineData()
    return g
}

func (g *Greet) GetData() int32 {
    return g.value + g.m.Get()
}

func (g *Greet) SetData(value int32) {
    g.value = value
    g.m.Set(value)
}
  • greet/greet_test.go
package greet

import (
    "mocktest/machine"
    "testing"
)

type fakeMachineData struct {
    machine.MachineData

    FakeGetData func() int32
    FakeSetData func(value int32)
}

func (f *fakeMachineData) Get() int32 {
    return f.FakeGetData()
}

func (f *fakeMachineData) Set(value int32) {
    f.FakeSetData(value)
}

func TestGetData1(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 10
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(3)
    value := mo.GetData()
    if value != 13 {
        t.Errorf("GetData: %v", value)
    }
}

func TestGetData2(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 15
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(5)
    value := mo.GetData()
    if value != 20 {
        t.Errorf("GetData: %v", value)
    }
}

2023年8月19日

golang: interfaceの勉強 (2)

使ったことがない interface だが、テストでモックを作ろうとするときはやっておいた方がよさそうだ。

hiro99ma blog: [golang] interfaceの勉強
https://hiro99ma.blogspot.com/2022/02/golang-interface.html


struct

golang には class はないが、struct で似たようなことはできる。
こういう意味が無いこともできる。

type Abc struct {}

func (a *Abc) Greet() {
  fmt.Println("Hello")
}

ここの「(a *Abc)」の a はレシーバーと呼ばれる。 class の this なんかに近いし、もし Abc の定義に変数があったなら a.xxx のようにしてアクセスできる。

そして Greet() はメソッドである。おそらくだが、レシーバーがない func は関数と呼んで、レシーバーがある func はメソッドと呼ぶんじゃないだろうか。まあ、C++とかでもそういう使い分けだったと思うし、一般的な呼び方をしておいてよさそうだ。
ちなみに構造体のメンバーは「フィールド」と呼ぶ。

この Greet() はAbc を参照しているわけではないし、そもそも Abc はフィールドを持つわけではないので関数であっても困らない。空の構造体はどういうシーンで使うんだろうか?
思いつくのはチャネルの待ち合わせだ。

hiro99ma blog: [golang] chan で待つ
https://hiro99ma.blogspot.com/2022/06/golang-chan.html

この記事では type を使わず直接 struct {} を使っているが、待ち合わせるチャネルが複数ある場合はそれぞれに type で名前を付けることになるだろう。

それ以外だと・・・特に共通で使うような変数がないけど機能としてまとめておいた方がわかりやすいがパッケージにするほどでもないようなときにグループ化する目的とか?

 

struct は既に定義してある struct を中に組み込むことができる。
このとき、その構造体にフィールド名を付けることもできるし、付けないこともできる。付けた場合は他のフィールドと同じようにドットを使って名前を使って参照する。名前を付けなかった場合はあたかも組み込んだ struct のフィールドがそこに展開されているかのように扱うことができる。

なので、こういう組み込みにした場合は軽い継承関係のようなものができているのかと思っていたのだが、キャストのようなことをして代入することはできないそうだ。unsafe とか使ってやってみようとしたのだが、どうにもダメだった。

 

そう、ダメだったのだ。
だからモックにしたい struct を組み込んだ struct を作ってテストしよう、というのはできないのだ。
そういう場合は interface を使うようにするそうである。

・・・というつもりで書こうとしていたのだが、「モックのためだけに interface を使うのってどうなのよ」みたいな記事も見つけてしまい、ちょっと揺らいでいる。

テストのためだけに`interface`を書きたくないでござる — KaoriYa
https://www.kaoriya.net/blog/2020/01/20/never-interface-only-for-tests/

ただまあ、めんどうになるくらいだったら interface を作ってもいいかなというくらいの気持ちだ。C言語でヘッダファイルを書くような感じで。

ちなみに↑の記事の方は、同じ struct 名を用意し、テストの時と本番用でビルドタグを切り替えて読み替える、というようなことをやっている。ビルドタグという機能を知らなかったのだが、ファイル単位で指定できるのは便利そうだ。

 

長くなったので interface については次回。

2022年7月10日

[golang] 埋め込む順番で type は異なる

構造体の勉強中。

interface は「こういうメンバたちを持ってるよね? 持ってないと我が一族の名を名乗れないからね?」という脅しだと思う。いや、コンピュータ言語で脅しても仕方ないのだが、コンパイルエラーになるという意味では脅しと受け取った方がよいんじゃなかろうか。

ここ数年 C++ から離れているが、 class のメソッドで =0 にしていると abstract なメソッドという扱いになって、必ず派生した class でオーバーライドしないといけないようになってた気がする。
=0 が 1つでも入っているとインスタンスにできなかったと思うので、それがなくなるごとに抽象度が減るという表現をするのかもしれない。

 

その interface と似てるような似てないようなのが「埋め込み」とか「annonymous field」というやつだと思う。今のところお仕事で使う機会が無いのだが、C言語で class 的なものを使いたい場合のやり方だと認識している。
C言語だと構造体のメンバを定義した順にメモリ配置するので、

struct A {
  int a;
  char b;
}

struct B {
  int a;
  char b;
  double c;
}

という構造体を用意すると、a と b については型とメモリ上のアドレス相対位置が一致するので struct A と struct B の変数は a と b については気にせずアクセスできる。
c については、 struct A の変数を struct B としてキャストすればアクセスはできるだろうが、読み込めるのはそのアドレスにあるデータなのでどうなるかは不明だ。まあ alignment はpack(0) とかしてなければ問題ないので死にはしないだろう。

結局のところ、メモリ上にあるものはすべて「データ」に過ぎない。
それがプログラムなのか文字列なのかExcelのデータなのかというのは後付けの理由だ。画像データなんてフォーマット以外の部分はバイナリデータに過ぎないので、そこにプログラムとして動作する値があったとしても不思議ではない。ウイルスだったりセキュリティホールだったりはそういうところからやってくるんだろう。

 

さて話を戻して。

struct の説明で、メンバの並びが違うと違うものとして扱われるというのをどこかで読んだ気がする。まあ、私は C言語のことを思い浮かべながら Go言語を見ているので、書いてなくても「きっとそうなんだろう」と思い込んでいるだけかもしれない。

埋め込みだとどうなのか、ちょっと確認してみよう。

package main

import "fmt"

func main() {
    // annonymous field
    type Name struct {
        name string
    }
    type Age struct {
        age int
    }
    type User1 struct {
        Name
        Age
    }
    type User2 struct {
        Age
        Name
    }

    var u1 User1
    var u2 User2
    u1.name = "kuma"
    u1.age = 98
    u2.age = u1.age
    u2.name = u1.name
    fmt.Printf("u1=%v\n", u1)
    fmt.Printf("u2=%v\n", u2)
    fmt.Printf("compare: %v\n", u1 == u2)
}

最後の u1 == u2 がコンパイルエラーになる。

invalid operation: u1 == u2 (mismatched types User1 and User2)

ただ・・・これはAge と Name が違うからではなく、純粋に struct で定義したものが違うからエラーにしているだけだと思う。並びを同じにしてもエラーになるからだ。

 

多少異なるのがキャストについてだ。
埋め込む順番を同じにした場合、 User2(u1) も User1(u2) もエラーにならない。

しかし Name(u1) も Name(u2) もエラーになる。
そこは通してやってもいいんじゃないかと思ったが、そうすると Age(u1) なんかも通さないといけなくなってしまうのかもしれない。メンバの先頭だけ OK というのは説明しづらいからな。

2022年7月3日

[golang] よく出てくる context.Context

通信するライブラリなどを使おうとするとしばしば登場するのが context.Context だ。
gRPC だとこんな感じ。

Basics tutorial | Go | gRPC
https://grpc.io/docs/languages/go/basics/#simple-rpc-1

context.Background() でコンテキストを作って与えておけば取りあえず使えるので深く考えずに使っていたのだが、真面目に実装していくと理解していないとまずいと感じた。というより、あまり理解していなくてコードレビューで指摘を受けてしまった。

よく出てくるのでほどほどに理解したい。
ネットで「golang context」で検索するとたくさん出てくるので、きれいな解釈はそちらを見た方がよいだろう。なら書くなよと思われそうだが、私は書かないと理解ができないタイプなので仕方ないのだ。


まずは godoc

context package - context - Go Packages
https://pkg.go.dev/context#Context

出てくるのは context.Context だが、パッケージの存在目的が Overview に書いてあるので目を通す。

  • プロセス間で伝播
    • デッドライン
    • キャンセル
    • シグナル
    • その他 request-scoped な値

「between proceses」とあるが、Linux でいうところのプロセスではなく goroutine を指してるのだろうか。
「request-scoped values」は、処理の要求を行ったコンテキストが持っている値だろうか。 goroutine だったらそういう値はがんばらなくても参照できそうなものだが、うーん?

「プログラミング言語Go」には context が載っていない。本は v1.5 のときに書かれているのだが context が生まれたのは v1.7 のようだ。ちなみに本では goroutine のキャンセルについて書かれており、それは channel を使って行うようになっている。

 

こちらが、よく紹介されている go.dev のブログ。

Go Concurrency Patterns: Context - The Go Programming Language
https://go.dev/blog/context

まあ、もう 8年も経っているので日本語で紹介しているサイトの文面を読むだけでいいや。。。


いろいろ使い道はあるのだが、主な使い方はキャンセル処理の通知だと思う。
チャネルを使えば処理の終了を待ち合わせることもできるし、キャンセル処理をさせることもできる。

hiro99ma blog: [golang] chan で待つ
https://hiro99ma.blogspot.com/2022/06/golang-chan.html

ただ、それをおのおのの実装でやっていくと違いが出てくるだろうし、似たような処理があちこちに出てきて格好が悪くなるから context にそういうのをまとめておいてみんな使いましょう、ということなのだろう。
A が Bライブラリを使って、 B が Cライブラリを使って、とやっていって、Aがキャンセルする処理を Bに伝えて、それを B が Cに伝えて、ということになるのをルール化したというところか。

なので、goroutine を走らせておいて「あとは好きにやっとけ」というタイプの処理だと使うことが無いかもしれない。多少なりとも goroutine を走らせた方が結果を待ったりするからこそ自分がキャンセルすることを下々に通知する必要が出てくると思われるからだ。

ただ、goroutine を呼び出した方が先に終了してしまうと goroutine の処理が終わる前に中断させられてしまうことになるから、何かしら終了を待つようなことにはなるのではなかろうか。
そう考えると、あまり難しく考えず、goroutine の中で context.Context を引数にとる API を使うなら その外側で context.Context を渡すようにした方がよい、くらいでいいのかな。

 

そういう見方をすると context のメンバーの用途がわかりやすい。

Done() は呼び出し元がキャンセルしたのを子が知るための channel 。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    fmt.Printf("start\n")
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    go func(ctx context.Context) {
        fmt.Printf("goroutine start\n")
        time.Sleep(10 * time.Second)
        fmt.Printf("goroutine done\n")
        <-ctx.Done()
        fmt.Printf("detect Done!")
    }(ctx)

    time.Sleep(5 * time.Second)
    cancel()
    fmt.Printf("main done.\n")
}

$ go run .
start
goroutine start
main done.

まあ、待ち始めるのが 10秒後なので、5秒後に cancel() するとそうなるよね。。。
だからといって goroutine の方を先に終わらせて Done() を待つというのは意味が無い。それなら goroutine を終われば良いだけだ。
となると、select で Done() を待つのと同じように、別の channel も待つようなシーンでないと意味が無いのか。

やるなら、cancel() を通知した後、自分が実行した goroutine が終わるのは待つようにするというところか。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    fmt.Printf("start\n")
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    done := make(chan struct{})
    go func(ctx context.Context) {
        fmt.Printf("goroutine start\n")
        time.Sleep(10 * time.Second)
        fmt.Printf("goroutine done\n")
        <-ctx.Done()
        fmt.Printf("detect Done!")
        done <- struct{}{}
    }(ctx)

    time.Sleep(5 * time.Second)
    cancel()
    <-done
    fmt.Printf("main done.\n")
}

5秒経過したら cancel() を呼び、待ち合わせている goroutine からの channel done を待ってから終了させる。
done を通知するのは自作の goroutine だから、done しなかったら自分のバグということでよいだろう。

では、もしその goroutine の中で別の goroutine を呼び出しているのであればどうするか?
同じだ。 Done() の channel を受け取ったら配下の goroutine をキャンセルさせるように通信して終わるまで待つのだと思う。

いやー、難しいね。

2022年6月19日

[golang] 空文字列の []byte キャストは nil ではない

ちょっとだけ不安になったので確認しておこう。

 

package main

import (
    "fmt"
)

func main() {
    x := []byte("")
    if x == nil {
        fmt.Printf("nil\n");
    } else {
        fmt.Printf("not nil\n");
    }
}

$ go run .
not nil

よかった、認識は間違えてなかった。
扱いとしては []byte{} のときと同じかな。

初期値だったり nil を代入しない限りは nil にならないという認識だ。
でないと struct{} なんかも nil になってしまって区別が付かなくなるはずだ。
ただ、 struct{} が必ず別の値になるとは限らないという記述をどこかで見かけた気がする。。。

2022年6月12日

[golang] chan で待つ (3)

2番目の記事で疑問になっていたところを解消しておこう。

hiro99ma blog: [golang] chan で待つ (2)
https://hiro99ma.blogspot.com/2022/06/golang-chan-2.html

のこちら。

その後で A が終わって待ち解除になると B 待ち状態になるが、既に処理が終わった B についてどうなるのかわからん。

についてだ。


まず、勘違いしていた件。

 

done := make(chan struct{}, 3)

こう書いたとしても、

done[0] <- struct{}{}

のようには書けないということだ。
make() は capacity を設定するものだから len() ではなく cap() を使って容量を取ってくるのだった。

 

それを踏まえて。

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Printf("start\n")
	done := []chan struct{}{
		make(chan struct{}),
		make(chan struct{}),
		make(chan struct{}),
	}
	go func() {
		fmt.Printf("goroutine start - 1\n")
		time.Sleep(10 * time.Second)
		fmt.Printf("goroutine done - 1\n")
		done[0] <- struct{}{}
		fmt.Printf("goroutine sent - 1\n")
	}()
	go func() {
		fmt.Printf("goroutine start - 2\n")
		time.Sleep(5 * time.Second)
		fmt.Printf("goroutine done - 2\n")
		done[1] <- struct{}{}
		fmt.Printf("goroutine sent - 2\n")
	}()
	go func() {
		fmt.Printf("goroutine start - 3\n")
		time.Sleep(3 * time.Second)
		fmt.Printf("goroutine done - 3\n")
		done[2] <- struct{}{}
		fmt.Printf("goroutine sent - 3\n")
	}()
	fmt.Printf("waiting...\n")
	<-done[0]
	fmt.Printf("done - 1\n")
	<-done[1]
	fmt.Printf("done - 2\n")
	<-done[2]
	fmt.Printf("done - 3\n")
	fmt.Printf("all done\n")
}

実行。

$ go run .
start
waiting...
goroutine start - 3
goroutine start - 1
goroutine start - 2
goroutine done - 3
goroutine done - 2
goroutine done - 1
goroutine sent - 1
done - 1
done - 2
done - 3
goroutine sent - 3
all done

時間の経過が見えないが、「goroutine done - 1」以降は一気に出力されている。
「sent」のログは全部出ていないが、これはその前にプロセスが終了したからだろう。

まあ、これなら前回の最後に書いた for でぐるぐる回して待つ方がシンプルに見えるな。

[golang] chan で待つ (2)

golang の goroutine は、確か実装依存だったと思う。
Linux だったらきっと pthread なんだろうな、と思っていたが、そうではなくて自前で並列処理を作っていたような記憶がある。
まあ、使う方としてはそこまで意識をしないけど、OS 無しだったり独自OS だとどうなるのか気になるね。


さて、前回は 1つのチャネルで 1つの処理が終わるのを待つのを確認した。処理結果がいらない場合にわざわざ struct{}{} を返すので、別に bool とかでいいんじゃないとも思ったが、本に struct{}{} を返すよう書かれているので、そういうお作法と考えるのが良いだろう。値を返す、ということ自体が結構めんどうな処理になりそうだしね。

では複数の goroutine が全部終わるのを待つ場合も考えよう。
make() を使うので第2引数に待ちたいだけの数を設定して待てばよさそうな気がしたのだが、for で待つにしてもどの順番で処理が終わるか分からないから、make() で 3つ作って順に 処理A, B, C に割り当てたとすると、A を待っている間に B, C が先に終わってしまうこともあるだろう。その後で A が終わって待ち解除になると B 待ち状態になるが、既に処理が終わった B についてどうなるのかわからん。


 それはともかく、make()で複数の chan を作るのは「バッファ有りチャネル」として紹介されていた。
本の説明では 3つ作っている。そして 4つめは「送信文は待たされます」と書かれている。ということは chan は受信待ちだけでなく送信待ちというものもあるということか。
ただ、これは対象がスライス全体を与えているからそうなるのだと思う。スライスの各要素で送受信するようにしたらバッファ無しのチャネルと同じになるはずだ。

あるいは、スライス全体にすることで「早い者勝ち」になるようだから、それをループで回数だけ待てばよいはずだ。

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Printf("start\n")
	done := make(chan struct{}, 3)
	go func() {
		fmt.Printf("goroutine start - 1\n")
		time.Sleep(10 * time.Second)
		fmt.Printf("goroutine done - 1\n")
		done <- struct{}{}
	}()
	go func() {
		fmt.Printf("goroutine start - 2\n")
		time.Sleep(5 * time.Second)
		fmt.Printf("goroutine done - 2\n")
		done <- struct{}{}
	}()
	go func() {
		fmt.Printf("goroutine start - 3\n")
		time.Sleep(3 * time.Second)
		fmt.Printf("goroutine done - 3\n")
		done <- struct{}{}
	}()
	for range done {
		<-done
	}
	fmt.Printf("done\n")
}

実行。

$ go run .
start
goroutine start - 3
goroutine start - 1
goroutine start - 2
goroutine done - 3
goroutine done - 2
goroutine done - 1
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
        /home/xxx/golang/src/chan/main.go:30 +0x125
exit status 2

あれ、ダメなんだ。
for の回数を固定させるとエラーは起きないようなので range done が

package main

import (
	"fmt"
	"time"
)

func main() {
	const eventNum = 3
	fmt.Printf("start\n")
	done := make(chan struct{}, eventNum)
	go func() {
		fmt.Printf("goroutine start - 1\n")
		time.Sleep(10 * time.Second)
		fmt.Printf("goroutine done - 1\n")
		done <- struct{}{}
	}()
	go func() {
		fmt.Printf("goroutine start - 2\n")
		time.Sleep(5 * time.Second)
		fmt.Printf("goroutine done - 2\n")
		done <- struct{}{}
	}()
	go func() {
		fmt.Printf("goroutine start - 3\n")
		time.Sleep(3 * time.Second)
		fmt.Printf("goroutine done - 3\n")
		done <- struct{}{}
	}()
	for i := 0; i < eventNum; i++ {
		<-done
	}
	fmt.Printf("done\n")
}

実行。

$ go run .
start
goroutine start - 3
goroutine start - 1
goroutine start - 2
goroutine done - 3
goroutine done - 2
goroutine done - 1
done

本には、

  • len() は現在バッファされている要素の個数を返す
  • cap() はバッファ容量を返す

とある。
range done が len(done) と同じルールならダメそうだ。
本によると、 range でチャネルを回すのはチャネルに対して送信されたすべての値を受信するときと書かれているので len()と同じなのだろう。

いろいろやってみらんとわからんもんやね。

[golang] chan で待つ

オライリーさんからGo言語の本が出たので悩み中。

O’Reilly Japan - 実用 Go言語
https://www.oreilly.co.jp/books/9784873119694/

まだプログラミング言語Goも読み進めていないので早すぎるという気もするが、お仕事で使っている以上実用の本もほしいのが正直なところだ。
まあ、そのうち買うんだろうね。


さて、本題。

処理Aがあって、その処理の後に処理Bを行いたいことがあった。
それだけなら続けて書けば良いだけだったのだが、コンテキストが同じ状態で処理Aと処理Bを実行できないようで(自分で作ってない処理なのでよくわからん)、処理A は goroutine してやらないと処理Bが必ず失敗していた。
つまり、処理Aが非同期になったのだ。

今は処理Aが終わりそうな時間だけtime.Sleep()で待ってから処理Bを実行させているのだが、そういえば非同期処理の待ち合わせがあったなあ、と思い出した。
channelだ。
まあ、goroutine と channel はプログラミング言語Goでも同じ章で説明してあるくらいだしセットで覚えるものよね。

チャネルでの待ち合わせ

チャネルはmake()で作り、close()で閉じられる。使わなければよいだけなのだろうけど、明示的に「これ以降は使えない」というフラグを立ててくれるそうだ。

make(chan 型)で作るが、型は戻り値と思っておけばよさそうだ。
TypeScriptでいえばPromise<型>みたいな感じかな。
単に待ち合わせたいだけだったら戻り値はいらないのだが、そういうときはstruct {}を使えばよいようだ。golangにvoidはないのだね。

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Printf("start\n")
	done := make(chan struct{})
	go func() {
		fmt.Printf("goroutine start\n")
		time.Sleep(10 * time.Second)
		fmt.Printf("goroutine done\n")
		done <- struct{}{}
	}()
	<-done
	fmt.Printf("done\n")
}

実行。

$ go run .
start
goroutine start
goroutine done
done

10秒開けているのだけど、終わってからdoneが実行されている。

2022年6月5日

[golang] go.mod の pseudo-version は go mod tidy で修正される

相変わらず go.mod で悩んでいた。

hiro99ma blog: [golang] go.mod の pseudo-version の調べ方がわからん
https://hiro99ma.blogspot.com/2021/11/golang-gomod-pseudo-version.html

hiro99ma blog: [golang] go.mod の pseudo-version
https://hiro99ma.blogspot.com/2021/12/golang-gomod-pseudo-version.html

なんとなく pseudo-version の書き方は分かったものの、面倒であることに変わりは無い。

開発中は replace で相対パス指定しておけばごまかせるのだが、GitHub Actions で linter を仕込んでいたりするとエラーになって気持ちが悪い。 Actions の方も相対パスで使えるようにすることができるのかも試練が、そこまでするくらいだったら go.mod を修正した方が楽そうだが、修正が面倒。。。

 

何か pseudo-version を自動で取ってくるツールがないか調べていた。

Mastering Go Modules Pseudoversions | JFrog GoCenter
https://jfrog.com/blog/go-big-with-pseudo-versions-and-gocenter/

真ん中当たりに「How to Fix Improper Pseudo-versions」という項目があり、修正の仕方が載っていた。なんと go mod tidy でうまいことやってくれるそうだ。

書き方は、pseudo-version を書く代わりに git の commit-id を書くだけ。これで go mod tidy すると pseudo-version に書き換えてくれた。 replace のところでもよいようだ。

今までの苦労は一体。。。

 

まあよい。できれば良かろうなのだ。

2022年5月29日

[golang] 配列の比較とスライスの比較

似てるようで似ていない golang の配列とスライス。

 

配列同士の比較

package main

import "fmt"

func main() {
    array1 := [...]int{1, 2, 3}
    array2 := [...]int{2, 2, 3}
    fmt.Printf("array1 == array2: %v\n", array1 == array2)
    array2[0] = 1
    fmt.Printf("array1 == array2: %v\n", array1 == array2)
}

$ go run .
array1 == array2: false
array1 == array2: true

 

配列は宣言時の要素数がそのまま型として扱われると考えておくと良いだろう。
なので、[3]int と [4]int は別の方だから実行時に失敗するのではなくコンパイルエラーになる。

    array3 := [...]int{1, 2, 3, 4}
    fmt.Printf("array1 == array3: %v\n", array1 == array3)

invalid operation: array1 == array3 (mismatched types [3]int and [4]int)

 


スライスは直接の比較ができない。

    slice1 := array1[:]
    slice2 := array2[:]
    fmt.Printf("slice1 == slice2: %v\n", slice1 == slice2)

invalid operation: slice1 == slice2 (slice can only be compared to nil)

 

よく出てくるのが reflect.DeepEqual() を使う方法だった。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    array1 := [...]int{1, 2, 3}
    array2 := [...]int{2, 2, 3}
    array3 := [...]int{1, 2, 3, 4}

    slice1 := array1[:]
    slice2 := array2[:]
    slice3 := array3[:]
    fmt.Printf("slice1 == slice2: %v\n", reflect.DeepEqual(slice1, slice2))
    fmt.Printf("slice1 == slice3: %v\n", reflect.DeepEqual(slice1, slice3))
    array2[0] = 1
    fmt.Printf("slice1 == slice2: %v\n", reflect.DeepEqual(slice1, slice2))
    slice1 = append(slice1, 4)
    fmt.Printf("slice1 == slice3: %v\n", reflect.DeepEqual(slice1, slice3))
}

$ go run .
slice1 == slice2: false
slice1 == slice3: false
slice1 == slice2: true
slice1 == slice3: true

配列をスライスに変換しているのは、単に前のコードを使い回していただけで意味はない。
いま気付いたが、スライスに変換しているといっても、その場で値をコピーしてまるまる別物になるわけではないのだな。
なんでかというと、array2[0] に代入したら slice1 と slice2 が同じ値と判定されているからだ。
COW(Copy On Write)かな?

package main

import (
    "fmt"
)

func main() {
    array2 := [...]int{2, 2, 3}
    slice2 := array2[:]

    slice2[0] = 1
    fmt.Printf("array2[:]: %p\n", &array2)
    fmt.Printf("slice2: %p\n", slice2)
    slice2 = append(slice2, 4)
    fmt.Printf("slice2: %p\n", slice2)
}

$ go run .
array2[:]: 0xc0000ae000
slice2: 0xc0000ae000
slice2: 0xc0000a8030

さすがに明示的に変数への代入をしない限りは書き換わらないか。

 

[]int 型なので reflect.DeepEqual() を使ったが、 []byte 型の場合は bytes.Equal() がある。

package main

import (
    "bytes"
    "fmt"
)

func main() {
    array1 := [...]byte{1, 2, 3}
    array2 := [...]byte{2, 2, 3}
    array3 := [...]byte{1, 2, 3, 4}

    slice1 := array1[:]
    slice2 := array2[:]
    slice3 := array3[:]
    fmt.Printf("slice1 == slice2: %v\n", bytes.Equal(slice1, slice2))
    fmt.Printf("slice1 == slice3: %v\n", bytes.Equal(slice1, slice3))
    array2[0] = 1
    fmt.Printf("slice1 == slice2: %v\n", bytes.Equal(slice1, slice2))
    slice1 = append(slice1, 4)
    fmt.Printf("slice1 == slice3: %v\n", bytes.Equal(slice1, slice3))
}

$ go run .
slice1 == slice2: false
slice1 == slice3: false
slice1 == slice2: true
slice1 == slice3: true

 

シンプルなスライスだったら reflect.DeepEqual() を使うのにちゅうちょしないのだが、構造体のスライスとかになると心配になって使いづらい。説明が長いだけで使うのに不安を感じる。

理解して使えばよいのだが、それくらいだったら自分でループ回して比較した方が安心だと考えてしまう。比較するメソッドを作ればそこまで苦痛ではないだろう。

DeepEqual の実装は説明文に比べるとかなり短い。 go1.18.2 だとこうなっていた。

func DeepEqual(x, y any) bool {
    if x == nil || y == nil {
        return x == y
    }
    v1 := ValueOf(x)
    v2 := ValueOf(y)
    if v1.Type() != v2.Type() {
        return false
    }
    return deepValueEqual(v1, v2, make(map[visit]bool))
}

・片方でも nil があるなら単純比較
・型が違えば false
・deepValueEqual()

短いのは条件だけだからだった......

単純比較は nil 同士なら true になるかと思ったのだがそうではなかった。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type MyType1 = struct {
        Value int
    }
    type MyType2 = struct {
        Value float32
    }
    var val1 *MyType1
    var val2 *MyType2
    val1 = nil
    val2 = nil
    fmt.Printf("val1=%v, val2=%v, compare=%v\n", val1 == nil, val2 == nil, any(val1) == any(val2))
    fmt.Printf("val1 == val2: %v\n", reflect.DeepEqual(val1, val2))
}

$ go run .
val1=true, val2=true, compare=false
val1 == val2: false

なお、型が違うので val1 == val2 と書くとコンパイルエラーになる。

 

DeepEqual() で期待している比較の処理は deepValueEqual() で行われていて、こちらは長い。
あまり見ていないが、型によって比較の仕方が違うから処理に時間がかかりそうだ。
パフォーマンスを気にするシーンだったら自前で書いた方がよさそう。

2022年5月8日

[golang]go.modの入れ子を理解できなかった

go.mod をずいぶん理解できたんじゃないかと思っていたのだが、入れ子になった場合、つまり サブディレクトリの中にも go.mod がある場合にどうしたらよいのかがわからなかった。

 

なんで入れ子にしようとしたかというと、gRPC 用の proto ファイルを別管理しようとしていたからだ。過去の記事にも同じことを書いたような気がするが、

  • proto ファイルをサーバ側のアプリと同じリポジトリに置いた
  • でも proto ファイルの方はバージョンが変わらずサーバアプリだけ更新されることが多い
  • うーん、ならば go.mod を別にした方がよいのでは?

という思考からだ。

リポジトリごと分ける方が無難なのだろうけど、それはそれでやりすぎな気がしてそうしたのだ。
サーバもクライアントもアプリが小さいなら同じリポジトリに置いてしまってよかったかもしれないが、clone するだけで大ごとになるようなサイズなので「サーバ+proto」「クライアント」の2つに分けている。

と「仕方ない」という感を出そうと思ったが、初回のリリースまでは proto もサーバアプリと同じ go.mod にして、リリースしたらどうせ tag を付けるだろうからバージョン管理で逃げてしまえばよかったと思う。
開発中は tag を付けていないので、go.mod に書くときは commit-id を元にした pseudo-version を使っている。

 

入れ子にしたのはこれだけではなかった。
クライアント側も gRPC にアクセスする部分だけ go.mod を別にしてしまったのだ。
gRPC のテスト用クライアントアプリを別に作ったので、gRPC アクセス部分だけ使い回そうとしたのだ。

そんなこんなして、面倒な構成になってしまった。
実際はこんなにシンプルではなく、もっと大量に import している。

image

こうなったとき、go.mod をどう書いて良いのかが結局分からなかった。
go mod tidy してもエラーが出て、いろいろ書き換えても解消できなくなったのだ。 replace を使ってローカルディレクトリを参照したのも原因かもしれない。

結局あきらめて、クライアントアプリの grpcアクセス部分は go.mod を削除して単にクライアントアプリの 1パッケージとして使うことにした。

image


悔しいからいうわけではないが、この構成に変更してよかったと思う。
そもそも、テストアプリはテストアプリに過ぎないのだから、そのために苦労しすぎるのは馬鹿らしい。
それに、grpc の部分を本格的に別のところでも使いたいならクライアントアプリとは別リポジトリにすべきだろう。サーバが複数あることは考えにくいからセットにしたが、クライアントは種類が複数あっても変ではないのだ。

 

だから構成を変更したことに対しては文句がないのだが、その理由が「できなかった」というのは納得がいかないものだ。
できるけどやらない、くらいにしておきたい。

というわけで、入れ子になった go.mod 環境を作って試していこう(本題)。


その前に、用語の整理をしたい。
パッケージは goファイルの中に package として書くのでわかるのだが、モジュールとかバージョンになるとちゃんと理解できていない。今回だって「go.mod の入れ子」と書いているが、正式な名称じゃないと思う。

Modules, packages, and versions
https://go.dev/ref/mod#modules-overview

モジュール

これは package なんかの集合で、識別はモジュールパスで行われる。
モジュールパスは go.mod に依存関係などと一緒に書く。
モジュールルートディレクトリは go.mod があるディレクトリ。
メインモジュールはちょっと違って、go コマンドを実行したディレクトリに含まれているモジュールを指す。つまりルートディレクトリの下にあるサブディレクトリで go コマンドを実行しても、そこに go.mod が含まれていなければ上にたどって直近にある go.mod のモジュールがメインモジュールになるということだ。

git で管理していて普通に作るなら、モジュールパスは git のリポジトリと同じにするだろう。 git 以外でも同じようなものだろう。
ローカルファイルでも悪くはないと思うのだが、どうなんだろうね。


というわけで、ローカルディレクトリで試していこう。

$ go version
go version go1.18.1 linux/amd64

最近は GOPATH を使わなくてもよくなりつつあるようだが、よくわからんので GOPATH を使う。

$ export GOPATH=`pwd`
$ mkdir bin src
$ cd src
$ mkdir mod1 mod2
$ cd mod1
$ go mod init
$ cd ../mod2
$ go mod init
$ cd ..

これで mod1 と mod2 というモジュールができた。
モジュールパスも mod1 と mod2。

なにか import させて go.mod を賑やかにしたいので、昔作った gogo-test1 を持ってこよう。

$ cd mod1
$ go get github.com/hirokuma/gogo-test1
go: downloading github.com/hirokuma/gogo-test1 v0.0.0-20211121014212-382e4677bbfb
go: github.com/hirokuma/gogo-test1@v0.0.0-20211121014212-382e4677bbfb requires
        github.com/hirokuma/yoshio@v0.0.0: reading github.com/hirokuma/yoshio/go.mod at revision v0.0.0: git ls-remote -q origin in /home/xxxx/golang/pkg/mod/cache/vcs/301146d5f0494aad6678724d644f7711fa7ff362d0bc8683a33b7d297ca8e2c3: exit status 128:
        remote: Repository not found.
        fatal: repository 'https://github.com/hirokuma/yoshio/' not found

なんだこりゃ?と思ったが、 gogo-test1 の go.mod で require github.com/hirokuma/yoshio にしてて、それを replace で github.com/hirokuma/gogo-test2 にしているだけだ。

gogo-test1 を clone して go mod tidy してもエラーにならない。
もしかして replace って import すると使えなくなったりするんだろうか。

依存関係がない gogo-test4 はすんなり go get できた。

$ go get github.com/hirokuma/gogo-test4

go.mod

module mod1

go 1.18

require github.com/hirokuma/gogo-test4 v0.1.0

 

main.go

package main

import (
    "fmt"

    gogo "github.com/hirokuma/gogo-test4"
)

func main() {
    gogo.SetValue(3)
    fmt.Printf("%v\n", gogo.GetValue())
}

$ go run .
3


hirokuma/gogo-test1 がダメな理由だが、なんとなく tag で付けた v3 もよくない感じがする。
gogo-test1/go.mod にあった replace をこちらにも追加したのだが、これはダメだった。

$ go mod tidy
go: errors parsing go.mod:
/home/ueno/golang/src/mod1/go.mod:7: no matching versions for query "v3"

module mod1

go 1.18

replace github.com/hirokuma/yoshio v0.0.0 => github.com/hirokuma/gogo-test2 v0.0.0-20211121012830-b239fb1fd1ae

require github.com/hirokuma/gogo-test1 v3

 

こっちだと go mod tidy できた。

module mod1

go 1.18

replace github.com/hirokuma/yoshio v0.0.0 => github.com/hirokuma/gogo-test2 v0.0.0-20211121012830-b239fb1fd1ae

require github.com/hirokuma/gogo-test1 v0.0.0-20211121014212-382e4677bbfb

 

tag に v0.0.3 という名前で追加しても成功したので、 x.y.z 系の tag を付けておくのが無難ということか。
本題とは関係ないのに時間がかかってしまった。


というところで気付いたが、ローカルディレクトリだとバージョンも何もないので意味が無いのでは・・・?

とりあえずやっておこう。

src/
  mod1/
    go.mod
    main.go
  mod2/
    go.mod
    gogo.go

 

mod2/go.mod

module mod2

go 1.18

mod2/gogo.go

package mod2

import "fmt"

func Gogo() {
    fmt.Printf("mod2 GoGo!\n")
}

 

mod1/go.mod

module mod1

go 1.18

replace github.com/hirokuma/yoshio v0.0.0 => github.com/hirokuma/gogo-test2 v0.0.0-20211121012830-b239fb1fd1ae
replace mod2 => ../mod2

require github.com/hirokuma/gogo-test1 v0.0.0-20211121014212-382e4677bbfb
require mod2 v0.0.0

mod1/main.go

package main

import (
    "fmt"
    "mod2"

    "github.com/hirokuma/gogo-test1/gogo"
)

func main() {
    fmt.Printf("gogo-test1!\n")
    gogo.Gogo()
    mod2.Gogo()
}

$ cd mod1
$ go run .
gogo-test1!
gogo!
mod2 GoGo!

mod2 は replace するから require しなくてもよいかと思ったが、それはダメだった。


ここで、mod2 の下に modmod2 を追加する。

image

 

mod2/modmod2/gogogo.go

package modmod2

import "fmt"

func Gogogo() {
    fmt.Printf("modmod2 GoGo!\n")
}

そして mod1 で使う。

 

mod1/go.mod

module mod1

go 1.18

replace github.com/hirokuma/yoshio v0.0.0 => github.com/hirokuma/gogo-test2 v0.0.0-20211121012830-b239fb1fd1ae
replace mod2 => ../mod2
replace modmod2 => ../mod2/modmod2

require github.com/hirokuma/gogo-test1 v0.0.0-20211121014212-382e4677bbfb
require mod2 v0.0.0
require modmod2 v0.0.0

mod1/main.go

package main

import (
    "fmt"
    "mod2"
    "modmod2"

    "github.com/hirokuma/gogo-test1/gogo"
)

func main() {
    fmt.Printf("gogo-test1!\n")
    gogo.Gogo()
    mod2.Gogo()
    modmod2.Gogogo()
}

$ go run .
gogo-test1!
gogo!
mod2 GoGo!
modmod2 GoGo!

 

なんというか、これだと単にディレクトリの位置が違うというだけで、入れ子になっているのは関係ないことになる。

バージョンのことを除けば、go.mod が入れ子になろうと関係がないということかしら。
いつも親?のモジュール名のサブディレクトリっぽいモジュール名を付けていた(今回なら mod2/modmod2 みたいな)ので go.mod がないときと同じように扱っていたのだが、全然違うモジュール名を付けていてもなんとかなったのかもしれない(どうやってリポジトリと紐付けるのかは知らんが)。

mod2/gogo.go から modmod2.Gogogo() を呼ぶこともできた。

package mod2

import (
    "fmt"
    "modmod2"
)

func Gogo() {
    fmt.Printf("mod2 GoGo!\n")
    modmod2.Gogogo()
}

こちらは mod2/go.mod に追加せずにできた。

mod1/go.mod のように追加しなければならないかと思ったのだが、そこはサブディレクトリという特権なのか?
ディレクトリ名を mod2/modmod2 から mod2/modmodmod2 に変更だけしてみたら、mod1/go.mod の replace したパスが存在しないというエラーになった。

$ go run .
../mod2/gogo.go:5:2: modmod2@v0.0.0: replacement directory ../mod2/modmod2 does not exist

mod1/go.mod の replace を ../mod2/modmodmod2 に変更すると go run できた。
なんで mod2/gogo.go は変更しなくてよかったのだろう?
キャッシュかもしれんと考えて各 go.mod があるディレクトリで go clean -modcache と go clean -cache を実行したが変わらなかった。

まあ、やっぱりサブディレクトリの特権ということか。


そう考えると、あまりサブディレクトリに go.mod を持つ利点よりも、バージョン管理が難しくなる欠点が目立ちそうなので避けたい気もする。

最初に書いた proto のディレクトリに go.mod を付けたとしても、tag をディレクトリごとに付けられるわけでもないので、やるなら v0.0.1-proto みたいにサフィックスを付けるとかになるんだろうか。

バージョンの付け方は go.dev に説明がありそうだったが・・・読む気にならん。

Minimal version selection (MVS)
https://go.dev/ref/mod#minimal-version-selection

 

golang の言語仕様自体は結構シンプルな印象を受けているのだが、 go.mod のことで悩む時間が多いのがきついところだ。なんとなく、バージョン管理にまで口を出す傲慢な言語、っていうイメージになってしまった。まあ Java が出てきたときも「ディレクトリが言語に合わせないといけないなんて!」と思ったので今さらかもしれん。オープンソースとはいえ開発主体があるならその意向に沿ってしまうのは仕方ないだろう。嫌なら自分で開発すれば良いだけなのだから。

 

最後の方になって役に立ちそうな記事を見つけた。

Go のモジュール管理【バージョン 1.17 改訂版】
https://zenn.dev/spiegel/articles/20210223-go-module-aware-mode

ありがたや。