HN 日本語サマリー

← 一覧へ戻る
プログラミング

OCamlとEioを試してみた

Taking OCaml and Eio for a Spin (mattjhall.co.uk)

46 pointsby mattjhall6 コメント

要約

著者は、最近注目を集めている関数型プログラミング言語OCamlと、そのエフェクトベースの並行処理フレームワークEioを試した経験を共有しています。学習リソースの評価、言語の感触、そしてEioを使ったシンプルなRPCサーバーの実装について詳しく述べています。

全文翻訳

OCamlとEioを試してみた

このウェブサイトでの私の最初のブログ記事はHaskellについてでした。私は常にファンクショナルプログラミングに興味がありましたが、Haskellの複雑さはそれに見合うほどではないように感じていました。

OCamlについては長い間漠然と知っていましたが、実際に触れることはありませんでした。最近、マルチコアサポートやエフェクト、Jane Streetによるよりシステム寄りのOxCamlといった動きで、OCamlは再び注目を集めています。今が学ぶのに良い時期だと感じ、特に並行処理フレームワークであるEioに興味を持ちました。Eioは前述のエフェクトを使用しますが、私にとってより興味深いのは、テストに役立つ可能性のある決定論的な動作を目指している点です。

書籍とチュートリアル

まず最初に行うべきことは、チュートリアルや書籍を選ぶことです。簡単なGoogle検索の後、Real World OCamlを見つけました。Real World Haskell(私が楽しんで、非常に実践的だと感じた本)に似ているだろうと仮定し、すでに十分なFPのスキルを持っていると信じて、飛び込みました。

構文やセマンティクスを早く見たいという焦りから、より説明的な序文は飛ばしてしまいました。もし読んでいれば、その本がJane StreetのBase標準ライブラリ代替を使用することを知ったでしょう。歴史的に、実際の標準ライブラリはコンパイラのニーズをカバーするだけで、かなり貧弱だったようです。これはもはや真実ではなく、徐々に成長しています。それでも、Real World OCamlという名前の本が、その言語の最大の実際のユーザーからのライブラリを使用することは、私にとって不合理ではないように思えます。

とにかく、私は物事をより注意深く読むという教訓を確実に学び、最初に戻ってやり直しました。本の最初の半分はよく書かれており、私は楽しくついていきました。しかし、GADTsやファーストクラスモジュールあたりで迷子になり始めました。本には演習が不足しているように思われ、何か馴染みのないことが出てきても、基本的な部分を完全に理解していないと、それを乗り越えることができません。

もっと簡単なものを求めて探したところ、CS3110を見つけました。これは、あらゆる好みに合うようにビデオとテキストの両方を提供しています。また、演習もあり、大いに役立ちました。OCamlを学びたい人には、まずこのコースから始めて、より高度な機能についてはRWOに進むことをお勧めします。RWOは気に入っていますが、RWHのようなプロジェクトベースの本を探しているなら、がっかりするでしょう。

手に持った感触

全体として、OCamlはコードを書くのが非常に楽しい言語です。ファンクショナルプログラミングと命令型プログラミングの良いミックスを持っています。例えば、リストをループするには、再帰関数かList.mapとその仲間を使用します。

let print_recursive list = 
  let rec loop i list = 
    match list with 
    | [] -> ()
    | x :: xs ->
      Printf.printf "[%d] => %s\n"
      loop (i+1) xs
  in
  loop 0 list

let print_fn = List.iteri (fun i x -> Printf.printf "[%d] => %s\n" i x)

let () = 
  print_recursive ["foo"; "bar"; "baz"];
  print_fn ["foo"; "bar"; "baz"];

(*
[0] => foo
[1] => bar
[2] => baz
[0] => foo
[1] => bar
[2] => baz
*)

しかし、必要であればミュータブルな変数なども使用できます。

type client = { mutable request_id : int }

let dispatch cli ~msg = 
  let request_id = cli.request_id in
  cli.request_id <- request_id + 1; (* update request_id *)
  
  Printf.printf "Dispatching %d/%s to server\n" request_id msg

let () = 
  dispatch_cli ~msg:"Hello";
  dispatch_cli ~msg:"World"

(*
  => Dispatching 0/Hello to server
  => Dispatching 1/World to server
*)

構文は少し冗長に感じます。例えば、let .. inやmatch .. withの構文です。プログラミング言語において構文は私にとって最も興味のない部分です。Rustがシジルを使っていた頃でさえ満足していましたので、あまり気になりません。名前付き引数(~付き)があるのは非常に良い点です。

コンパイラの方が気になります。エラーが発生すると、ファイルの残りの部分の解析を諦めてしまうようです。これにより、イテレーションループが非常に遅くなります。コードを書いて、エラーが出て、エラーを修正して、再ビルドするという流れです。特に一つのモジュールに集中している場合、エラーをまとめて修正する機会はほとんどありません。

Eio

EioはエフェクトベースのI/O並行処理ライブラリです。比較的新しいですが、io_uringサポートなど興味深い機能を持っています。最終的な目標は、Raft合意アルゴリズムの実装を書き、それをテストすることです。

Raftの論文では、サーバー間の通信にリモートプロシージャコール(RPC)を使用すると述べられています。単純なRPCクライアント/サーバーは、最初のプロジェクトとして最適でしょう。非常にシンプルなプロトコルを考えてみましょう。プロシージャコールは、リクエストID(int)、名前(string)、および単一の引数(string)を持ちます。整数は1バイト、文字列はバイトで長さをシリアライズし、その後にデータを続けます。例えば、リクエストID10でEchoプロシージャをHelloで呼び出す場合、以下のようなデータを送信します。

00000000: 0a04 4563 686f 0548 656c 6c6f            ..Echo.Hello

応答は、リクエストIDと文字列の戻り値のみになります。

始める前に、Eioがビルディングブロックとして使用するいくつかの専門用語に慣れておく必要があります。

  • Fiber - 実行のスレッド。ただし、システムスレッドではありません!
  • Switch - ファイバーをグループ化するものです。Goのsync.WaitGroupに似ています。
  • Flow - 読み書きできるものです。
  • Stream - バウンドされたスレッドセーフなキューです。Goのチャネルのようなものです。
  • Promise - これはご存知でしょう。

サーバーから始めると、Flowを受け取り、ループして、そこからプロシージャコールを読み込み、呼び出し、応答を送信する必要があります。

open Utils

type conn = {
  src : Eio.Buf_read.t;
  sink : Eio.Buf_write.t;
}

let rec conn_loop conn = 
  let request_id = Eio.Buf_read.uint8 conn.src in

  let procedure_name = read_string conn.src in
  let body = read_string conn.src in
  
  traceln "rx %d/%s(%s)" request_id procedure_name body;

  (* In a real RPC system we might dispatch the invocation to a worker pool *)
  let res = match procedure_name with 
  | "Echo" -> body
  | "Capitalise" -> String.capitalize_ascii body
  | _ -> failwith "unknown procedure"
  in

  traceln "tx %d/%s(%s) => %s" request_id procedure_name body res;

  Eio.Buf_write.uint8 conn.sink request_id;
  write_string conn.sink res;

  conn_loop conn

サーバーは多くの接続を持つ可能性があるため、接続を保持する型を定義します。ここではFlowを直接使用せず、代わりにBuf_readまたはBuf_write型を使用していることに注意してください。これは、バッファリングされた読み書きを使用し、より効率的にするためです。Flowに対する操作は、基盤となるリソース(ソケット、ファイルなど)に直接行われます。幸いなことに、これらのバッファリングされたリーダー/ライターには、ここでリクエストIDの送受信に使用しているような、型を読み書きするための便利なヘルパー関数があります。

read_string/write_stringはUtilsから来ています。

let read_string src = 
  let len = Eio.Buf_read.uint8 src in
  Eio.Buf_read.take len src
  
let write_string sink s = 
  Eio.Buf_write.uint8 sink (String.length s);
  Eio.Buf_write.string sink s

次に、バッファリングされたFlowを取得し、ループを実行するためのヘルパーが必要です。

let handle_conn flow = 
  let src = Eio.Buf_read.of_flow ~max_size:1024 flow in
  Eio.Buf_write.with_flow flow @@ fun sink ->
  conn_loop {src; sink}

そして、テスト実行ファイルです。

open Dumb_rpc
open Eio.Std

let port = 1470

let () = 
  Eio_main.run @@ fun env ->
  Eio.Switch.run @@ fun sw ->
  let net = Eio.Stdenv.net env in

  let handle_client flow addr = 
    traceln "Accepted connection from %a" Eio.Net.Sockaddr.pp addr;
    Dumb_rpc.Server.handle_conn ~sw flow
  in

  let addr = `Tcp (Eio.Net.Ipaddr.V4.loopback, port) in
  let socket = Eio.Net.listen net ~sw ~reuse_addr:true ~backlog:5 addr in
  Eio.Net.run_server socket handle_client
    ~on_error:(traceln "Error handling connection: %a" Fmt.exn)

これでテストする準備ができました。

> printf '\x00\x04Echo\x05Hello' | nc localhost 1470 -q0
Hello⏎
> printf '\x01\x0aCapitalise\x07matthew' | nc localhost 1470 -q0
Matthew⏎

素晴らしい!

クライアント

クライアントについては、もう少し凝って、並行して安全に使用できるようにしましょう。そのためには、一度に1つのプロシージャコールだけをソケットに書き込むようにする必要があります。これは2つのファイバーを使用して行います。1つは読み込み用、もう1つは書き込み用です。書き込み用ファイバーは、メソッドが呼び出されたときに追加するストリームから作業を取得します。

type request = { procedure : string; arg : string; }

type t = { 
  mutable request_id : int;
  writeq : request Eio.Stream.t; (* Read right to left: stream of request *)
}

let rec send_loop cli w = 
  let req = Eio.Stream.take cli.writeq in
  let request_id = take_and_inc_request_id cli in
  write_request request;
  send_loop cli w

let invoke cli ~procedure ~arg = 
  let req = {procedure; arg;} in
  Eio.Stream.add cli.writeq req;

しかし、応答を呼び出し元にどうやって返すのでしょうか?そのためには、ストリームにもプロミスを送信し、リクエストIDをキーとしてハッシュテーブルに格納します。これは、サーバーが応答したときに後で解決できます。Eioでは、プロミスは実際には2つの半分に分割されていることに注意してください。待機する側(Promise.t)と解決する側(Promise.u)です。

type waiter = { resolver : string Eio.Promise.u; }

type request = { 
  procedure : string;
  arg : string;
  resolver : string Eio.Promise.u;
}

type t = { 
  mutable request_id : int;

  writeq : request Eio.Stream.t;
  waiters : (int, waiter) Hashtbl.t;
}

let rec send_loop cli w = 
  let req = Eio.Stream.take cli.writeq in
  let request_id = take_and_inc_request_id cli in
  Hashtbl.add cli.waiters request_id { resolver = req.resolver };
  
  traceln "tx %d/%s(%s)" request_id req.procedure req.arg;
  write_request request;

  send_loop cli w

let invoke cli ~procedure ~arg = 
  let (promise, resolver) = Eio.Promise.create () in
  let req = {procedure; arg; resolver; } in
  Eio.Stream.add cli.writeq req;

  Eio.Promise.await promise

受信ループは、応答を読み取り、プロミスを解決できます。

let rec recv_loop cli r = 
  let (request_id, body) = read_response
  
  traceln "rx %d => %s" request_id body;
  let waiter = Hashtbl.find cli.waiters request_id in
  Promise.resolve waiter.resolver body;
  
  recv_loop cli r

以下のように、複数の異なるファイバーから使用できます。

open Eio.Std

let port = 1470

let () = 
  Eio_main.run @@ fun env ->
  Eio.Switch.run @@ fun sw ->
  let net = Eio.Stdenv.net env in

  let addr = `Tcp (Eio.Net.Ipaddr.V4.loopback, port) in
  let flow = Eio.Net.connect ~sw net addr in

  let cli = Dumb_rpc.Client.create () in
  Eio.Fiber.fork_daemon ~sw (fun () -> Dumb_rpc.Client.run cli ~flow; `Stop_daemon);
  
  for i = 0 to 5 do
    Eio.Fiber.fork ~sw (fun () ->
      let arg = Printf.sprintf "arg-%d" i in
      traceln "Invoking Echo(%s)" arg;
      let res = Dumb_rpc.Client.invoke cli ~procedure:"Echo" ~arg in
      traceln "Got response Echo(%s) => %s" arg res
    )
  done

そして、それが機能していることを確認できます。

> ./_build/default/bin/client.exe
+Invoking Echo(arg-0)
+Invoking Echo(arg-1)
+Invoking Echo(arg-2)
+Invoking Echo(arg-3)
+Invoking Echo(arg-4)
+Invoking Echo(arg-5)
+tx 0/Echo(arg-0)
+tx 1/Echo(arg-1)
+tx 2/Echo(arg-2)
+tx 3/Echo(arg-3)
+rx 0 => arg-0
+Got response Echo(arg-0) => arg-0
+tx 4/Echo(arg-4)
+rx 1 => arg-1
+Got response Echo(arg-1) => arg-1
+rx 2 => arg-2
+tx 5/Echo(arg-5)
+Got response Echo(arg-2) => arg-2
+rx 3 => arg-3
+rx 4 => arg-4
+Got response Echo(arg-3) => arg-3
+Got response Echo(arg-4) => arg-4
+rx 5 => arg-5
+Got response Echo(arg-5) => arg-5

結論

全体として、OCamlは学ぶのが楽しく、使いやすい言語でした。FPでありながら命令型も実行でき、コンパイルは速く、例外と値としてのエラーの選択肢があるなど、多くの点で優れています。ユーザーベースはかなり小さいですが、それが表れていると思います。開始するための最良の方法が明確ではなく、研究するためのコードもあまり多くありません。

Eioは、Goを使ったことがある人なら誰でも親しみを感じるでしょう。それをいじくり回しているうちに、Flowが閉じられるという問題に何度もつまずきましたが、それはrun_serverのコールバックのような場所でブロックすべきところにファイバーを起動してしまったことが原因でした。

うまくいけば、すぐに動作するRaft実装を持って戻ってこれるでしょう。