[ruby-dev:43901] ThreadGroup#make_local_space! (Re: ThreadGroup の強化案)

永井＠知能．九工大です．少々長いメールで失礼します．

ThreadGroup の強化案の改定版です．
まだ未完成ですが，試験的に実装した部分 (rev.32226 との差分) を添付します．

このサンプルで試していただける重要な要素は
ThreadGroup#make_local_space! です．
これはメソッド等に ThreadGroup 固有の空間を作ります．
local space を持つ ThreadGroup 内で定義されたメソッドは
その ThreadGroup 内でのみ有効となります．
他の ThreadGroup では元々のメソッドが見えており，影響を受けません．
# メソッドの undef への対応も必要ですが，そこは未実装です．
# メソッド以外の local space はまだ実装できていません．

ThreadGroup 固有の空間ですから，sub thread を作成されても大丈夫です．
ThreadGroup#enclose と組み合わせることで，
sandbox 作成などにも役立つのではないかと思います．
新しい ThreadGroup を作成したときには，それを作成した thread の
ThreadGroup が持つ local space を共有するようにしています．
その新しい ThreadGroup で make_local_space! を呼ぶと
現在の local space のコピーを作成して独立するという仕様です．
# この部分は未テストです．

以下がサンプルスクリプトです．
どの ThreadGroup でどのメソッド定義が見えているかに注目ください．
御意見などいただけますと幸いです．

---<thgrp_local_space-sample.rb>------------------------------------
thgrp = ThreadGroup.new
class A
  def A.bar
    p [Thread.current.group, :BAR]
  end
  def A.foo
    p [Thread.current.group, :HOGE]
  end
  def foo
    p [Thread.current.group, :hoge]
  end
end

a = A.new

A.bar; A.foo; a.foo
# => [#<ThreadGroup:0x0000000087a988>, :BAR]
#    [#<ThreadGroup:0x0000000087a988>, :HOGE]
#    [#<ThreadGroup:0x0000000087a988>, :hoge]


thgrp.new_thread{ A.bar; A.foo; a.foo }.join
# => [#<ThreadGroup:0x00000000b89778>, :BAR]
#    [#<ThreadGroup:0x00000000b89778>, :HOGE]
#    [#<ThreadGroup:0x00000000b89778>, :hoge]

# Make local space on thgrp, and define on the local space
thgrp.make_local_space!
thgrp.new_thread{
  def A.foo
    p [Thread.current.group, :FUGA]
  end
  class A
    def foo
      p [Thread.current.group, :fuga]
    end
  end
}

thgrp.new_thread{ A.bar; A.foo; a.foo }.join
# => [#<ThreadGroup:0x00000000b89778>, :BAR]
#    [#<ThreadGroup:0x00000000b89778>, :FUGA]
#    [#<ThreadGroup:0x00000000b89778>, :fuga]

A.bar; A.foo; a.foo
# => [#<ThreadGroup:0x0000000087a988>, :BAR]
#    [#<ThreadGroup:0x0000000087a988>, :HOGE]
#    [#<ThreadGroup:0x0000000087a988>, :hoge]

Thread.new{
  A.bar; A.foo; a.foo
  # => [#<ThreadGroup:0x0000000087a988>, :BAR]
  #    [#<ThreadGroup:0x0000000087a988>, :HOGE]
  #    [#<ThreadGroup:0x0000000087a988>, :hoge]

  thgrp.add Thread.current
  A.bar; A.foo; a.foo
  # => [#<ThreadGroup:0x00000000b89778>, :BAR]
  #    [#<ThreadGroup:0x00000000b89778>, :FUGA]
  #    [#<ThreadGroup:0x00000000b89778>, :fuga]

  ThreadGroup::Default.add Thread.current
  A.bar; A.foo; a.foo
  # => [#<ThreadGroup:0x0000000087a988>, :BAR]
  #    [#<ThreadGroup:0x0000000087a988>, :HOGE]
  #    [#<ThreadGroup:0x0000000087a988>, :hoge]
}.join
--------------------------------------------------------------------
============================================================================

[ ThreadGroup の強化プラン ]

*** はじめに ***
Ruby の ThreadGroup は，単なる Thread 集合の制御だけではなく，
Thread 生成後に ThreadGroup を変更できるという性質により，
手続きや Thread (生成される sub-thread を含む) に操作可能な文脈を与えたり，
簡易 sandbox 作成を支援したりすることも可能である．
しかしながら，現在の ThreadGroup のメソッド群 (と機能) は，
そうした利用をサポートするには十分とは言えない．

例えば，thread 群に処理を分散させて結果を得る場合を考える．
thread 群を ThreadGroup にまとめたとしても，
現在は ThreadGroup 全体に対するメソッドに欠けるため，
結局は thread 群のリストを得て個別にメソッドを呼ぶ必要がある．
これではせっかく ThreadGroup を使用していても，その価値が低い．
また，ネットワークを介しているなどで thread が処理途中で例外終了する可能性があり，
そのような場合はすぐに代替 thread を起動する必要があるとすると，
システムが滞りなく動作するには多数の thread の実行状況を監視し続ける必要がある．
現在の Ruby でこれを行うには polling で状態を追う必要があり，効率が悪い
(いつどの thread がどういう理由で終了するかわからないので join では待てないため)．
あるいは，待つべき thread を指定して別 thread で warp することで
終了順に serialize する方法 (対象 thread の明示が必要であったり，
thread 数が倍増することになる点が嬉しくない) を取る必要がある．
ThreadGroup の強化プランでは，そうしたケースでの処理効率改善も含める．

なお，添付ライブラリの thwait (TheadsWait クラス) が類似した機能を持つ存在だが，
同ライブラリの機能は，本来，ThreadGroup が担うべきものである．
その意味では，ThreadsWait と同じインスタンスメソッドも用意しておくべきであろう．
ThreadsWait のインスタンスメソッド群は次の通り．
--------------------------------------------
ThreadsWait#all_waits
ThreadsWait#all_waits{|thread| ...}
ThreadsWait#empty?
ThreadsWait#finished?
ThreadsWait#join(*threads)
ThreadsWait#join_nowait(*threads)
ThreadsWait#next_wait(nonblock = nil)
ThreadsWait#threads
--------------------------------------------
ThreadsWait と ThreadGroup との大きな違いは，
生成された sub-thread が自動的に管理下に置かれるかどうかにある．
ThreadsWait は，ThreadGroup 横断で thread を待たねばならない場合と，
別の ThreadGroup を生成してまとめることができない thread 群を待たねばならない場合
とで有効性を維持する．
後者のような例が本当に存在するかは分からないが，少なくとも前者のような例はあり得る．


*** 単純な Thread 操作メソッドの不足 ***
特定の ThreadGroup に Thread を生成するには，
Thread を生成した上で対象の ThreadGroup に移動するしかなかった．
しかしそれでは ThreadGroup を移動する前に
Thread の処理が進行してしまう可能性が高く，
それを回避するために Thread を一旦 stop しておいて
移動後に wakeup する必要があった．

この問題への対策として，ThreadGroup#new_thread を導入する．
実行には，現在の ThreadGroup で生成した thread を
レシーバの ThreadGroup に移動する権限を持つことが必要であるとする．

その他，例えば ThreadGroup に属する Thread すべての終了を待つようなメソッド
ThreadGroup#join のように，ThreadGroup を Thread 集合として操作するために
不足と思えるメソッドを追加する．


*** ThreadGroup の dominate ***
現在の ThreadGroup では，enclose された場合に
外部から Thread を導入する手段がない．
enclose とはそういうものだからという話はあるが，
enclose された ThreadGroup を監視する Thread (ThreadGroup) 側からすると，
少々心許ない制約である．
例えば，監視対象の ThreadGroup 内に管理用 Thread の類が必要となりうるなら，
enclose する前にそうした Thread を生成しておく必要がある．
また，もし何らかのトラブルで管理用 Thread が落ちてしまうと回復の方法がない．

そこで，ThreadGroup 間に dominate という関係を規定する．
ある ThreadGroup A が別の ThreadGroup B を dominate しているならば，
A に属する Thread は，B に，あるいは B から Thread を移動させることができる．
ただし，B だけでなく Thread の移動元/移動先にも A が移動権限を持たねばならない．
Thread の移動権限を持つのは ThreadGroup の操作権限を持つ場合で，
  * 対象が制約無しの ThreadGroup
  * 対象が domanated で，自身が対象を dominate している ThreadGroup の Thread
のいずれかの場合である．

dominate している ThreadGroup A との関係を除いては，
dominate されている ThreadGroup B は enclose されている場合と同じ制約を持つ．

なお，dominated → enclosed → frozen の関係は一方通行であり，
状態変更後は元に戻すことはできない．


*** Thread が持つアクセス権限 ***
現在の ThreadGroup には，
ThreadGroup 環境からの Jail Break を防ぐための enclose という機構があるが，
enclose された ThreadGroup 内の Thread の権限についてはきちんとした規定がない．

ThreadGroup を enclose する目的は，ThreadGroup によって与えられた文脈から
不用意に離脱してしまわないようにという安全策の意味もあるが，
特定の Thread 群を信用できないというケースもあるだろう．
そう考えると，enclose や freeze された ThreadGroup から
他の ThreadGroup に属する Thread を操作することは認めるべきではないと言える．
逆に，そうした操作を許すことができるのなら，
わざわざ enclose や freeze をする必要は乏しいと考える．

よって，enclose または freeze された ThreadGroup の Thread が，
権限のない他の ThreadGroup の Thread を操作することを禁止することが望ましい．
具体的には，Thread のインスタンスメソッドの内，
---------------------------------------------------
[]=, abort_on_exception=, exit, kill, terminate, 
priority=, raise, run, wakeup
---------------------------------------------------
である (状態参照は許すが，状態変更は許さない)．
しかし，互換性を失うためにこの制約を直接導入することは難しいだろう．
ゆえに，デフォルトでは従来通り制約はなしとしておき，
制約を設定管理するためのメソッドとして
ThreadGroup#lock, ThreadGroup#locked? を導入する．
この場合，enclose などをされていない ThreadGroup に
制約を付与することも可能ではある (ユースケースは乏しそうだが…)．


*** ThreadGroup の thread_queue ***
冒頭で述べたような polling の問題を回避するために，
終了した thread を受けとるための thread_queue を ThreadGroup が持てるようにする．
thread_queue は，終了した Thread を
終了順にできるだけ早く楽に処理にかけるための機構である．

もちろん，動作させる thread の処理内容に
終了をレポートする処理を書いておくという方法もないわけではないが，
それを実装するとなると少々面倒であろう．
終了した thread が自動的に特定の queue に追加されるなら
(この処理は C レベルで Coding する必要がある)，
管理側がその queue から読み出して実行する処理を書くだけで良く，
面倒な部分を隠蔽することができる．
管理対象となるのは Thread の集合であるから，
ThreadGroup にそうした queue を持たせるのは妥当と言える．

thread_queue は一つの ThreadGroup につき一つだけとする．
thread_queue のモードは，正常終了，例外終了のそれぞれに対し，
thread_queue に追加する/しないの２種類を設定する．
デフォルトは「いずれも追加しない」である．

メモリ消費の爆発を避けるため，デフォルトでは thread_queue のサイズを有限とし，
保持サイズを超えた場合は古い Thread から捨てることとする．

thread_queue のアクセスには権限が必要である．
自らが制約を持たないか，自らが対象の ThreadGroup を dominate している場合に限り，
対象の ThreadGroup の thread_queue へのアクセスを許すこととする．


*** ThreadGroup の固有データ ***
Thread に文脈を与えるためには ThreadGroup に文脈を規定するデータを保持させる．
もし新しい Thread が生成されても，自動的に現在の ThreadGroup に所属するため，
ThreadGroup による文脈が保持される (ThreadGroup を移動すれば，文脈も変更される)．

これまでは Thread のように ThreadGroup に固有データを持たせるためのメソッドが
定義されてはいなかったため，Thread クラス同様に固有データを扱うメソッドを追加する．


*** メソッド一覧 ***
ThreadGroup.new()
ThreadGroup.new(hash)
  ThreadGroup 固有データを設定する引数を追加
  current ThreadGroup を親 ThreadGroup として保持する

ThreadGroup.current
  Thread.current.group に同じ

ThreadGroup.queueing
  current thread をその threadgroup の thread queue に入れる
  thread queue への投入が許可されていなければ，例外を生じる

ThreadGroup#add(thread)
ThreadGroup#add(*threads)
  複数の thread を一度に受付できるように，引数パターンを拡張
  max_threads を超過する場合は，例外を生じる

ThreadGroup#<<(thread)
  ThreadGroup#add(thread) に同じ

ThreadGroup#list
  従来と同じ

ThreadGroup#threads
  ThreadsWait と同等のメソッドを揃える目的で追加するメソッド
  実体は ThreadGroup#list

ThreadGroup#max_threads
ThreadGroup#max_threads=(size)
  ThreadGroupに含めることが可能な最大 thread 数を設定/参照する
  値 0 を設定した場合は無制限となる
  制限を超過するような処理が実行された場合は例外を生じる
  設定時にすでに ThreadGroup に存在する thread 数よりも少ない値を
  設定しようとした場合，値を指定通りに設定した上で例外を生じる

ThreadGroup#size
ThreadGroup#length
  呼んだ時点でThreadGroupに属するthreadの数を返す

ThreadGroup#enclose
ThreadGroup#enclosed?
  従来と同じ
  ただし，dominated であれば enclosed? は true となる

ThreadGroup#lock
ThreadGroup#locked?
  他の ThreadGroup に属する Thread の操作制約の設定と状態参照

ThreadGroup#[]
ThreadGroup#[]=
ThreadGroup#key?(key)
ThreadGroup#keys
  ThreadGroup 固有データへのアクセス
  現在の ThreadGroup がレシーバの操作権限を持たない場合には参照・変更は不許可
  ( 現在の ThreadGroup == レシーバの場合は操作権限あり )

ThreadGroup#new_thread(){ ... }
  レシーバの ThreadGroup に新しい thread を生成 (Thread.newと同じ)
  引数は Thead#new と同じ
  実行は，現在の ThreadGroup からレシーバへの Thread 移動権限を持つことが必要

ThreadGroup#start_thread(){ ... }
ThreadGroup#fork_thread(){ ... }
  レシーバの ThreadGroup に新しい thread を生成 (Thread.{start,fork}と同じ)
  引数は Thead#new と同じ
  ThreadGroup#new_thread と違って Thread#initialize を呼ばない
  実行は，現在の ThreadGroup からレシーバへの Thread 移動権限を持つことが必要


ThreadGroup#new_thread_of(klass,...){ ... }
ThreadGroup#start_thread_of(klass,...){ ... }
ThreadGroup#fork_thread_of(klass,...){ ... }
  生成する thread が klass クラスのものであることを除いては new_thread 等と同じ
  ただし，klass は Thread クラスのサブクラスでなければならない

ThreadGroup#dominate(threadgroup)
  レシーバが引数の threadgroup を dominate するようにする
  引数の threadgroup が enclose されていなければ enclose される
  現在の ThreadGroup がレシーバと引数との両方に操作権限を持たなければ例外を発生
  もし，引数の threadgroup == レシーバなら，例外を発生する

ThreadGroup#dominate?(threadgroup)
  レシーバが threadgroup を dominate しているなら true を返す
  現在の ThreadGroup がレシーバと引数との操作権限を持たない場合には例外となる
  現在の ThreadGroup == 引数の場合，enclosed 以上であれば権限なしとする
  ( enclosed 以上の ThreadGroup が自分の dominate 状態を調べるのを禁止するため )

ThreadGroup#dominated?
  レシーバを dominate している ThreadGroup を返す
  現在の ThreadGroup がレシーバの操作権限を持たない場合には例外となる
  現在の ThreadGroup == レシーバの場合，enclosed 以上であれば権限なしとする
  ( enclosed 以上の ThreadGroup が自分の dominate 状態を調べるのを禁止するため )

ThreadGroup#make_local_space!
  レシーバに local space を作成する
  レシーバがすでに固有の local space を持つ場合は何もせずに戻る
  レシーバが継承された local space を持つ場合は，
  それをコピーしたものを固有の local space として設定する
  一度設定された local space を除去することはできない
  local space を持つ threadgroup の thread が新たに threadgroup を生成した場合，
  その local space が新たな threadgroup に継承 (共有) される

ThreadGroup#has_local_space?
  レシーバが local space を持つかどうかを真偽値で返す
  真を返す場合，その local space が固有のものか継承されているものかは問わない

ThreadGroup#join(exception=false)
ThreadGroup#join(limit, exception=false))
  ThreadGroup のすべての thread が終了するのを待つ
  次項の ThreadsWait と同等の機能を持たせるための書式も参照すること
  引数 limit (秒単位の数値) が指定されていれば，その時間で timeout する
  join を呼んだ後に生成された thread であっても終了を待つ
  終了した thread を配列にして返す
  引数 exception については，
  nil であるときは，例外を生じた thread は破棄してそれ以外の thread のみを返す
  true であるときは，例外の有無に限らずすべての thread を戻り値の配列に含める．
  false のときは，例外を生じた thread に出会った時点でその例外を発生させる

ThreadGroup#join(thread, ..., thread, exception=false)
ThreadGroup#join(thread, ..., thread, limit, exception=false))
  ThreadsWait と同等のメソッドを揃える目的で追加する引数バリエーション
  引数の最左群が thread オブジェクトである場合，
  それらの thread をすべてレシーバである threadgroup に add した後，
  残りの引数を使って ThreadGroup#join を呼ぶ．

ThreadGroup#join_nowait(*threads)
  ThreadsWait と同等のメソッドを揃える目的で追加するメソッド
  実体は ThreadGroup#add(*threads)

ThreadGroup#wait_queueing()
ThreadGroup#wait_queueing(*threads)
  指定された thread 群のすべてが threadqueue に入るのを待つ
  thread queue への投入許可がどの種の thread にもなされていなければ，例外を生じる
  引数指定がない場合，呼んだ時点で threadgroup に属するすべての thread を対象とする
  queueing 待ちの対象とされた thread すべてを配列にして返す

ThreadGroup#values(exceptions=false)
  すべての thread の戻り値を配列にして返す
  値と thread との対応が取れないので，値だけが必要な場合に用いる
  thread との対応が必要なら，join で得た thread の配列に対して each すること
  引数が nil であるときは，例外を生じた thread は破棄してそれ以外の戻り値のみを返す
  引数が true であるときは，例外は例外オブジェクトとして戻り値の配列に含める．
  引数が false のときは，例外を生じた thread に出会った時点でその例外を発生させる

ThreadGroup#exit
ThreadGroup#kill
ThreadGroup#terminate
  ThreadGroup のすべての thread を terminate する
  kill を呼んだ後に生成された thread であっても terminate する
  実体はこんな感じ
  ------------------------------------
  current = Thread.current
  Thread.exclusive do
    until((lst = self.list - current).empty?) do
      lst.each {|th| th.kill}
    end
  end
  current.kill if current.group == self
  ------------------------------------

ThreadGroup#each{|th| ... }
  呼んだ時点で ThreadGroup に含まれるすべての thread について繰り返す
  threadgroup.list.each{|th| ... } と同等

ThreadGroup#each_queueing{|th| ... }
  threadqueue に入れられた thread のそれぞれに対してブロックを実行する
  thread queue を利用するため，対象 thread は thread queue の mode に依存する
  thread queue への投入許可がどの種の thread にもなされていなければ，例外を生じる
  ThreadGroup に属する thread が存在しなくなれば終了する

ThreadGroup#all_waits
ThreadGroup#all_waits{|th| ... }
  ThreadsWait と同等のメソッドを揃える目的で追加するメソッド
  ブロックを与えられない時は ThreadGroup#join と同じ
  ブロックを与えられた時は ThreadGroup#each_join と同じ

ThreadGroup#thread_queue_pop(non_block=false)
  thread queue から終了した thread を一つ取り出す
  thread queue への投入許可がどの種の thread にもなされていなければ，例外を生じる

ThreadGroup#set_thread_queue_mode(succeed=false,exception=false,queueing=false)
  終了した thread を蓄える thread queue のモードの設定
  正常終了，例外終了，queueing のそれぞれに対し，thread を蓄えるかを真偽値で設定する

ThreadGroup#get_thread_queue_mode
  終了した thread を蓄える thread queue のモードの参照
  thread を蓄えるか否かの真偽値を [succeed, exception, queueing] の配列で返す

ThreadGroup#thread_queue_length
ThreadGroup#thread_queue_length=(len)
ThreadGroup#thread_queue_limit
ThreadGroup#thread_queue_limit=(len)
  thread queue の最大長を参照・設定する
  thread 数の爆発を防ぐためのもの
  最大長を超える場合は古い thread から捨てられる
  デフォルトの長さは，配列のデフォルト長さと同じ 16 としておく

ThreadGroup#thread_queue_empty?
  終了した thread を蓄える thread queue のが空かどうかを調べる
  queue が空であれば true を返す

ThreadGroup#finished?
  ThreadsWait と同等のメソッドを揃える目的で追加するメソッド
  実体は ! threadgroup.thread_queue_empty?

ThreadGroup#next_wait
  ThreadsWait と同等のメソッドを揃える目的で追加するメソッド
  実体は ThreadGroup#thread_queue_pop と同じ

ThreadGroup#abort_on_exception
ThreadGroup#abort_on_exception=(state)
  TreadGroup 内の thread での例外発生時にインタプリタ自体を終了させるか否か

ThreadGroup#raise
  現在 ThreadGroup に所属するすべての thread に例外を発生させる
  新たに生成された thread にまで例外を発生させる必要はなさそうなので、
  実体は Thread.exclusive{threadgroup.list.each{|th| th.raise(...)}} とする

ThreadGroup#alive?
  現在 ThreadGroup に所属する thread で生きているものが存在すれば true を返す

ThreadGroup#empty?
  ThreadsWait と同等のメソッドを揃える目的で追加するメソッド
  現在 ThreadGroup に所属する thread が存在しなければ true
  実体は threadgroup.list.empty? とする

ThreadGroup#wakeup
  現在 ThreadGroup に所属する thread のすべてを起こす
  実体は単純に Thread.exclusive{threadgroup.list.each{|th| th.wakeup}} とする


*** ThreadGroup には定義しない予定のメソッド ***
Thread にあるメソッドの内，以下は ThreadGroup での機能定義が難しいので
導入しない予定である．

ThreadGroup#value
  複数の Thread が対象となるので，ThreadGroup#values で定義

ThreadGroup#run
  現在 ThreadGroup に所属する thread のすべてを起こす
  wakeup は意味があると思うが，run は疑問 (どれに制御を移すべきかが規定不能)
  現在の thread list に順次 run をかけるという形はあり得るが．．．

ThreadGroup#priority
ThreadGroup#priority=
  現在 ThreadGroup に所属する thread のすべてに対して設定する．
  thread ごとに異なる可能性が高いので，参照は不可．

============================================================================
-- 
永井 秀利  ([e-mail])
九州工業大学大学院情報工学研究院知能情報工学研究系知能情報メディア部門助教