//--------------------------------------------------------------------------------
//少ない知識ですが、恩返しと思いページを立ち上げています。
//加筆修正、大歓迎です。  markovchainmontecarlo(2015/09)
//--------------------------------------------------------------------------------

&color(red){&size(30){並列計算 snowfallとその拡張};};~
~
マルチコアが主流となってきているので、並列計算のパッケージである「snowfall」を紹介します。~
なお、特に断りが無い場合はSocketクラスターを使用しています。~
なお、特に断りが無い場合は4個のSocketクラスターを使用しています。~
また、画像は縮小表示しています。クリックすると画像のみがオリジナルサイズで表示されます。~
~
&color(red){&size(40){現在編集中&br;調査中の内容があるため&br;信用に値しない内容も多分に含まれています。};};~
----
&color(red){&size(20){目次};};~
#contents
----
*========== 初級編 : snowfallを知る ========== [#xb2cafb4]
*並列計算で計算速度は向上するか? [#td6c7967]
**並列計算のイメージ [#y75f0c44]
#ref(./並列概念.jpg,50%);~
並列化できる割合によって、理論上の限界が変わってきます。~
([[アムダールの法則:https://ja.wikipedia.org/wiki/%E3%82%A2%E3%83%A0%E3%83%80%E3%83%BC%E3%83%AB%E3%81%AE%E6%B3%95%E5%89%87]]を参照)~
~
なお、計算負荷の不均一性やデータ入出力負荷が理由で、&size(20){&color(red){''かえって遅くなる''};};場合もあります。~
~
並列計算は計算速度向上の一つの手段にすぎません。~
計算速度向上の手段はいくつもありますので、適切な方法を用いてください。~
[[CRAN Task View: High-Performance and Parallel Computing with R:https://cran.r-project.org/web/views/HighPerformanceComputing.html]]
**どのような計算が並列化できるか [#v0613b1a]
基本的にapply familyは全て並列化可能です。~
詳細な条件としては、「計算の順序を入れ替えても計算結果が同じである」事になります。~
~
apply familyも内部ではforを使用しているので、並列化できるfor・並列化できないforが存在します。
-並列化できないforの例
--ケース1:依存関係がある。~
以下の例は、ひとつ前の数値に対して、関数hogeを適用するため並列化が出来ません。~
順序よくx[1] → x[2] → x[3] → x[4] → x[5] と実行しないと正しい計算ができません。
 for(i in 1:5){
     x[i] <- hoge(x[i - 1])
 }
これは、マルコフ連鎖にも言える事であり、マルコフ連鎖の生成スピードを上げようとするならばRcppを使用するなど並列計算ではない方法を用いなくてはなりません。~

--ケース2:グローバル変数など、現在の環境以外の数値を変更する~
以下の例は、Sys.sleepの時間によって休止する時間が不明であり、そのあとiをグローバル変数であるresultに代入するため並列化が出来ません。~
 for(i in 1:5){
     Sys.sleep(runif(1))
     result <<- i
 }
もし仮に、iが2の時の休止時間が一番長いとすると、これを並列計算してしまうとグローバル変数であるresultは2になってしまいます。

と、不安になるような事を書きましたが、上記のケースはどちらもsnowfallでは実現できないため、snowfallで並列計算を行う場合は気にしなくて大丈夫です。~
*各種パッケージ比較 [#bd4491f1]
|CENTER:package|CENTER:利点|CENTER:欠点|h
|parallel|・デフォルトパッケージとしてインストールされる。&br;・誰でも使用できる?|・下記「snow」「multicore」のコピーみたいなものなので、少々使いにくい。&br;・snowで使用できたクラスター稼働状況を調査する「snow.time」が使用できない。|
|multicore|・parallelパッケージの基礎となった優秀なパッケージ&br;(だと思う。ウィンドウズ環境しかないため使用していません。)|・うゐんどうずで動かない。|
|snow|・様々な関数が用意されている。&br;・parallelパッケージの基礎となった優秀なパッケージ&br;・クラスター稼働状況を調査する「snow.time」が使用できる。|・常にクラスターの指定をしなくてはならない。|
|snowfall|・クラスターの指定をする必要がない。&br;・関数の引数が(ほとんど)一緒。&br;・並列計算と通常処理を同じ関数でこなせる。|・「snow」に依存するため、バージョンアップで「snow」についていっているか確認が必要?|
*とりあえず動かす [#f88c02c8]
**主な流れ [#r8d6a8a4]
+ライブラリーの読み込み
 > library(snowfall)
  要求されたパッケージ snow をロード中です
+sfInitでクラスターを準備する。
 > sfInit(parallel = TRUE, cpus = 4)
 R Version:  R version 3.2.2 (2015-08-14)
 
 snowfall 1.84-6 initialized (using snow 0.3-13): parallel execution on 4 CPUs.
+(必要があれば)ワーカーに変数やオブジェクトを渡す。
 > a <- 1:10
 > sfExport("a")
+snowfall 関数を使用して並列計算を行う。
 > sfSapply(11:20, sum, a)
  [1] 66 67 68 69 70 71 72 73 74 75
+クラスターを止める
 > sfStop()
 
 Stopping cluster
**並列関数は何を使用するのか [#vaa0d523]
とりあえず以下に従って、関数を書き換えてください。~
引数は同じですので、いつも通りに計算できます。~
 apply  → sfApply
 lapply → sfLapply
 sapply → sfSapply
ためしにsfSapplyを実行。約3倍の速度!
 > library(snowfall)
  要求されたパッケージ snow をロード中です
 > sfInit(parallel = TRUE, cpus = 4)
 R Version:  R version 3.2.2 (2015-08-14)
 
 snowfall 1.84-6 initialized (using snow 0.3-13): parallel execution on 4 CPUs.
 
 > set.seed(123)
 > x <- sample(1:20)/4
 > system.time(sapply(x, Sys.sleep))
    ユーザ   システム       経過
        0.0        0.0       52.5
 > system.time(sfSapply(x, Sys.sleep))
    ユーザ   システム       経過
       0.01       0.00      15.50
 > sfStop()
 
 Stopping cluster
 
 >
*その他の関数を知る [#k38a8739]
|CENTER:関数|CENTER:内容|h
|sfSource|各クラスターにRファイルを読み込ませます。|
|sfLibrary|各クラスターにパッケージを読み込ませます。|
|sfExport|各クラスターに特定の変数を引き渡します。|
|sfExportAll|各クラスターに全ての変数を引き渡します。|
|sfRemove|各クラスターから特定の変数を削除します。|
|sfRemoveAll|各クラスターから全ての変数を削除します。|
|sfClusterCall|各クラスターに同一の命令を出します。|
|sfClusterEval|各クラスターに同一の命令を出します。&br;なお、expr()と同様に評価式を入れます。|
|sfClusterEvalQ|同上|
*Tips [#f5a8ee9b]
**cpu数 [#y089ac4b]
sfInitではcpusを指定します。~
~
ご自身のPCのCPU数を指定しますが、以下のコードも取得できます。~
なお、ハイパースレッディングを備えたCPUではスレッド数が取得されます。~
 > #parallelのdetectCoresを使用して取得します。
 > library(parallel)
 > detectCores()
 [1] 4
スレッド数を指定するか、CPU数を指定するかはどちらでもいいと思います。~
**通常処理と並列処理の切り替え [#a2d9ce5c]
通常処理と並列処理が同じ関数で出来ます。~
これは大変なメリットです!~
試しに行ってみましょう。~
~
まずは通常の並列計算。
 > sfInit(parallel = TRUE, cpus = 4)
 R Version:  R version 3.2.2 (2015-08-14) 
 
 snowfall 1.84-6 initialized (using snow 0.3-13): parallel execution on 4 CPUs.
 
 > sfSapply(1:10, sqrt)
  [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427 3.000000 3.162278

並列をせずに初期化しても、通常通り計算できます。
 > sfInit(parallel = FALSE)
 snowfall 1.84-6 initialized: sequential execution, one CPU.
 
 > sfSapply(1:10, sqrt)
  [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427 3.000000 3.162278

sfInitをし忘れても「sfInitしてないから、シーケンシャルで実行するね」と、自動的にsfInitを実行してくれます。
 > sfSapply(1:10, sqrt)
 Calling a snowfall function without calling 'sfInit' first or after sfStop().
 'sfInit()' is called now.
 snowfall 1.84-6 initialized: sequential execution, one CPU.
 
  [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427 3.000000 3.162278
**乱数の使用 [#jb088e8f]
**並列計算を中断した場合 [#f52f1c94]
並列計算を中断した場合は、必ずworkerをsfStop()で一度終了させてください。~
終了しないと、意図としない結果が返ってきます。~
 > #普通に実行
 > sfSapply((1:200)/1000, function(x){Sys.sleep(x); x})
   [1] 0.001 0.002 0.003 0.004 0.005 0.006 0.007 0.008 0.009 0.010 0.011 0.012 0.013 0.014 0.015 0.016 0.017
  [18] 0.018 0.019 0.020 0.021 0.022 0.023 0.024 0.025 0.026 0.027 0.028 0.029 0.030 0.031 0.032 0.033 0.034
  [35] 0.035 0.036 0.037 0.038 0.039 0.040 0.041 0.042 0.043 0.044 0.045 0.046 0.047 0.048 0.049 0.050 0.051
  [52] 0.052 0.053 0.054 0.055 0.056 0.057 0.058 0.059 0.060 0.061 0.062 0.063 0.064 0.065 0.066 0.067 0.068
  [69] 0.069 0.070 0.071 0.072 0.073 0.074 0.075 0.076 0.077 0.078 0.079 0.080 0.081 0.082 0.083 0.084 0.085
  [86] 0.086 0.087 0.088 0.089 0.090 0.091 0.092 0.093 0.094 0.095 0.096 0.097 0.098 0.099 0.100 0.101 0.102
 [103] 0.103 0.104 0.105 0.106 0.107 0.108 0.109 0.110 0.111 0.112 0.113 0.114 0.115 0.116 0.117 0.118 0.119
 [120] 0.120 0.121 0.122 0.123 0.124 0.125 0.126 0.127 0.128 0.129 0.130 0.131 0.132 0.133 0.134 0.135 0.136
 [137] 0.137 0.138 0.139 0.140 0.141 0.142 0.143 0.144 0.145 0.146 0.147 0.148 0.149 0.150 0.151 0.152 0.153
 [154] 0.154 0.155 0.156 0.157 0.158 0.159 0.160 0.161 0.162 0.163 0.164 0.165 0.166 0.167 0.168 0.169 0.170
 [171] 0.171 0.172 0.173 0.174 0.175 0.176 0.177 0.178 0.179 0.180 0.181 0.182 0.183 0.184 0.185 0.186 0.187
 [188] 0.188 0.189 0.190 0.191 0.192 0.193 0.194 0.195 0.196 0.197 0.198 0.199 0.200
 
 > #同じ作業を中断
 > sfSapply((1:200)/1000, function(x){Sys.sleep(x); x})
 
 > #変数を変えて20個のみ実行したが、前の結果が残っている?
 > sfSapply((1:20)/100, function(x){Sys.sleep(x); x})
   [1] 0.010 0.020 0.030 0.026 0.027 0.028 0.029 0.030 0.031 0.032 0.033 0.034 0.035 0.036 0.037 0.038 0.039
  [18] 0.040 0.041 0.042 0.043 0.044 0.045 0.046 0.047 0.048 0.049 0.050 0.051 0.052 0.053 0.054 0.055 0.056
  [35] 0.057 0.058 0.059 0.060 0.061 0.062 0.063 0.064 0.065 0.066 0.067 0.068 0.069 0.070 0.071 0.072 0.073
  [52] 0.074 0.075 0.076 0.077 0.078 0.079 0.080 0.081 0.082 0.083 0.084 0.085 0.086 0.087 0.088 0.089 0.090
  [69] 0.091 0.092 0.093 0.094 0.095 0.096 0.097 0.098 0.099 0.100 0.101 0.102 0.103 0.104 0.105 0.106 0.107
  [86] 0.108 0.109 0.110 0.111 0.112 0.113 0.114 0.115 0.116 0.117 0.118 0.119 0.120 0.121 0.122 0.123 0.124
 [103] 0.125 0.126 0.127 0.128 0.129 0.130 0.131 0.132 0.133 0.134 0.135 0.136 0.137 0.138 0.139 0.140 0.141
 [120] 0.142 0.143 0.144 0.145 0.146 0.147 0.148 0.149 0.150 0.151 0.152 0.153 0.154 0.155 0.156 0.157 0.158
 [137] 0.159 0.160 0.161 0.162 0.163 0.164 0.165 0.166 0.167 0.168 0.169 0.170 0.171 0.172 0.173 0.174 0.175
 [154] 0.176 0.177 0.178 0.179 0.180 0.181 0.182 0.183 0.184 0.185 0.186 0.187 0.188 0.189 0.190 0.191 0.192
 [171] 0.193 0.194 0.195 0.196 0.197 0.198 0.199 0.200
 
 > #残っているので再度実行して、うまくいっているように思われるが
 > sfSapply((1:20)/100, function(x){Sys.sleep(x); x})
  [1] 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.10 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.20
 
 > #やっぱり返る結果は意図としない結果。
 > sfSapply((1:200)/1000, function(x){Sys.sleep(x); x})
  [1] 0.001 0.002 0.003 0.004 0.005 0.006 0.007 0.008 0.009 0.010 0.011 0.012 0.013 0.014 0.015 0.016 0.017
 [18] 0.018 0.019 0.020 0.021 0.022 0.023 0.024 0.025 0.040 0.050 0.060 0.070 0.080 0.090 0.100 0.110 0.120
 [35] 0.130 0.140 0.150 0.160 0.170 0.180 0.190 0.200
**R起動時のsnowfallの設定 [#xaa75b4f]
起動時にsnowfallのsfInit使用時のデフォルト設定を指定することが出来ます。~
なお、各引数は[--args]の後に書きます。
|CENTER:引数|CENTER:内容|h
|--parallel|並列計算をデフォルトにする。|
|--cpus=X|並列計算におけるCPU数を指定する。|
|--type=X|クラスターのタイプを指定する。|
|--restoreSR|sfClusterApplySR使用時に、restoreをデフォルトにする。|
:例|Windowsでは以下のように指定するとsfInitの引数無しでも~
並列計算をデフォルトにし、CPU数は4、タイプはSOCKとします。
 "C:\hogehoge\Rgui.exe" --args --parallel --cpus=4 --type=SOCK
なお、リンク先をいじるなら、作業フォルダも変更した方が何かと便利です。
#ref(./R起動時のsnowfallの設定.JPG,50%);
*========== 中級編 : 並列関数の特性を知る ========== [#e2af6be3]
*並列処理問題BIG3 [#bd802150]
勝手にBIG3を決めてますが、意外とあたっていると思います。~
以降、この「並列処理問題BIG3」に気を付けながら紹介していきます。
**並列化コーディング問題 [#vfb08a35]
いくら並列化できるといっても、通常処理から並列化するのに関数をいちいち書き換えたりするのはとても面倒。~
一般的なイメージとして~
+まずは、通常処理を小規模なデータで意図とする結果が得られるかを確認
+小規模なデータはそのままに、並列化のコードに書き換えてエラーと格闘
+小規模なデータで並列化をして、通常処理と同じ結果が得られることを確認
+晴れて、大規模並列化へ

これ結構面倒ですよね。~
**計算負荷の不均一性問題 [#l77393f2]
計算負荷が均一の場合は、あまり気にせず並列化を行えます。~
24時間かかっていた処理を4コアで実行すると6時間で終わります。~
でも仮に、一つの計算がやたらと時間かかる場合で他のコアが待機状態になるコードを書いていたら~
実際は18時間位かかってしまうかもしれません。~
待機状態を以下に少なくして、PCやサーバー、ワークステーションの力を引き出してあげるかが重要です。~
**データ入出力負荷問題 [#xf03f030]
並列計算では、並列に計算します。(禅問答みたいですが・・・)~
並列に計算させるなら、それぞれの計算先にデータ(引数など)を送ったり、結果を受け取ったりします。~
大容量のデータ送受信が必要な場合、その時間は無視できません。~
計算自体の時間は早くなっても、それ以上にデータ入出力負荷がかかっては元も子もありません。~
:データの入力負荷問題|入力負荷は並列関数を工夫する事で減らすことができます。
:データの出力負荷問題|出力負荷は並列関数側ではどうにもできません。~
そのため、出力負荷問題は以降取扱いません。
*並列関数の特性調査 [#i4fc68eb]
**snow.time が無くては始まらない [#q3f29f95]
関数snow.timeを使用することによって、各クラスターの稼働状況を確認できます。~
この関数を使用しないと、各クラスターがいつ動いて、どれくらい入出力にかかっているかが分かりません。~
クラスターの稼働状況を知るためにも必須アイテムです。~
~
snow.timeによって稼働状況を取得
 > st <- snow.time(clusterApply(sfGetCluster(),sample(1:16),Sys.sleep))
printで概要が示されます。
 > print(st) #stだけでもOK
 elapsed    send receive  node 1  node 2  node 3  node 4 
   52.01    0.00   -0.02   24.02   33.00   45.01   34.03 
snow.timeの実態は2つの要素からから出来ています。。
snow.timeの実態は2つの要素からから出来ています。
 > names(st)
 [1] "elapsed" "data"   
総経過時間と各クラスターの詳細なデータになります。
 > st$elapsed
 elapsed 
   52.01 
 > st$data
 [[1]]
      send_start send_end recv_start recv_end  exec
 [1,]       0.00     0.00      11.00    11.00 11.00
 [2,]      13.99    13.99      14.99    14.99  1.00
 [3,]      23.00    23.00      25.02    25.01  2.02
 [4,]      39.00    39.00      49.00    49.00 10.00
 
 [[2]]
      send_start send_end recv_start recv_end  exec
 [1,]       0.00     0.00      11.00       11  2.99
 [2,]      13.99    13.99      22.99       23  9.00
 [3,]      23.00    23.00      38.01       38 15.01
 [4,]      39.00    39.00      49.00       49  6.00
 
 [[3]]
      send_start send_end recv_start recv_end  exec
 [1,]       0.00     0.00         14    13.99 14.00
 [2,]      13.99    13.99         23    23.00  7.00
 [3,]      23.00    23.00         39    39.00 16.00
 [4,]      39.00    39.00         49    49.00  8.01
 
 [[4]]
      send_start send_end recv_start recv_end  exec
 [1,]       0.00     0.00      13.99    13.99  3.99
 [2,]      13.99    13.99      23.00    23.00  5.01
 [3,]      23.00    23.00      39.00    39.00 12.02
 [4,]      39.00    39.00      52.01    52.01 13.01
plotすることで、視覚的にわかるようになります。~
(通常はplotして調査します。)
 > plot(st)
#ref(./snowTimingData.jpeg,50%);
-緑の四角:クラスター使用中~
-青の実線:結果をマスターに返すために待機中~
-赤の実線:マスターとクラスター間でデータの受け渡し~
-黒の破線:クラスター待機中~
**いきなりまとめ [#d5c07460]
いきなりですが、一覧表で特性をまとめてしまいます。~
(使用頻度の高いapply family を取り上げます。)~
|CENTER:package|CENTER:関数|CENTER:コーディング問題|CENTER:計算負荷問題|CENTER:入出力負荷問題|CENTER:備考|h
|snow|clusterApply|CENTER:&size(20){-};|CENTER:&size(20){×};|CENTER:&size(20){×};|ここから始まる並列関数。&br;なお、内部的にするのが主な目的なので、この関数をそのまま使用することはないと思います。|
|snowfall|sfClusterApply|CENTER:&size(20){-};|CENTER:&size(20){-};|CENTER:&size(20){-};|要素数が指定したcpusを超えると使えないなど多くの問題があります。&br;よって、評価対象外。|
|~|sfClusterApplyLB|CENTER:&size(20){-};|CENTER:&size(20){○};|CENTER:&size(20){×};|負荷分散(Load Balancing)を行うことにより、コンピュータの性能をフルに活かすことが出来ます。&br;なお、内部的にするのが主な目的なので、この関数をそのまま使用することはないと思います。|
|~|sfLapply&br;sfSapply&br;sfApply|CENTER:&size(20){○};|CENTER:&size(20){×};|CENTER:&size(20){○};|要素数を各クラスターへまとめて送るため入出力は1回のみとなり、入出力負荷問題が解決。&br;ただし、計算負荷問題は残る。|
|snow|clusterMap|CENTER:&size(20){×};|CENTER:&size(20){×};|CENTER:&size(20){×};|mapplyの並列版。クラスターの指定が必要だったりします。&br;評価は散々だけど、無いよりましな並列関数。|
|snowfall|sfClusterMap|CENTER:&size(20){-};|CENTER:&size(20){-};|CENTER:&size(20){-};|実は未実装。よって評価対象外。&br;実は他にも「関数はあるけど未実装」の関数がsnowfallにはあります。|
|snow|sfMM|CENTER:&size(20){?};|CENTER:&size(20){?};|CENTER:&size(20){?};|%*%の並列版。現在調査中|
**clusterApply [#f6b52c1b]
並列関数はここから始まったといっても過言ではない、全ての基となる並列関数です。~
:概要|1.各クラスターに対して、1要素を渡す。~
2.全てのクラスターから計算結果を受け取ってから、各クラスターに次の1要素を渡す。~
3.その繰り返し。~
:コーディング問題|以下の理由でコーディングは問題です。~
・パッケージがsnowで、クラスターの指定をしなくてはならない。~
・クラスターの指定があるので、通常・並列の切り替えが容易ではない。~
・そもそもsnowfallではないので、扱いにくい。~
:計算負荷問題|まずは準備。~
 > cl <- sfGetCluster()
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
で、並列計算。~
速くはなっていますが、待機時間が長い結果となっています。~
 > st <- snow.time(clusterApply(cl, arg.sleep, Sys.sleep))
 > st
 elapsed    send receive  node 1  node 2  node 3  node 4 
    0.89    0.00    0.00    0.62    0.53    0.35    0.61 
 > dev.new()
 > plot(st, title = "clusterApply")
#ref(./clusterApply.jpeg,50%)
:入出力負荷問題|今度は入出力負荷をかけた場合を見てみます。~
~
まずは準備。~
 > cl <- sfGetCluster()
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
 > fun.sleep <- function(x, ...) Sys.sleep(x)
 > arg.S <- NULL
 > arg.L <- numeric(10^7)
行う実験は、Rにarg.sleep分だけ寝てもらうので
 > sum(arg.sleep)
 [1] 2.1
のとおり、通常処理を行えば2.1秒で終了するはずです。~
~
さて、小さな引数を加えて並列処理を実行します。~
クラスターの待機状態がありながら、約2倍の高速化となりました。~
 > st.S <- snow.time(clusterApply(cl, arg.sleep, fun.sleep, arg.S))
 > st.S
 elapsed    send receive  node 1  node 2  node 3  node 4 
    0.88    0.00    0.00    0.64    0.55    0.35    0.57 
 > dev.new()
 > plot(st.S, title = "clusterApply with SmallArg")
#ref(./clusterApply with SmallArg.jpeg,50%)
今度は、大きな引数を加えて並列処理を実行します。~
なんと15.38秒と大幅に遅くなっています。~
各クラスターの実行時間はほとんど変わらないにも関わらず~
データの送信である「send」に非常に多くの時間がかかっているのが原因です。~
このように、大きなデータを扱う場合にはかえって遅くなる場合があるのです。~
 > st.L <- snow.time(clusterApply(cl, arg.sleep, fun.sleep, arg.L))
 > st.L
 elapsed    send receive  node 1  node 2  node 3  node 4 
   15.38   14.78    0.00    0.64    0.52    0.34    0.60 
 > dev.new()
 > plot(st.L, title = "clusterApply with LargeArg")
#ref(./clusterApply with LargeArg.jpeg,50%)
:総評|基本となる関数ではあるものの、コーディング問題もあるため~
単体で使用するケースはほとんどないと思われる。~
**sfClusterApplyLB [#b6d523e5]
clusterApplyの負荷分散(LoadBalancing)バージョンです。~
なお、各要素がどのクラスターで計算されるかはその時のクラスターの状態によるため~
計算時間やplot図が同じになることはありません。~
:概要|1.clusterApplyと同じように各クラスターに対して、1要素を渡す。~
2.一つのクラスターが計算を終えたら、即時次の要素をクラスターに渡す。~
3.その繰り返し。~
:コーディング問題|snowfallなので、通常・並列の切り替えが容易。~
ちなみに、通常時はlapplyに引き渡される。
:計算負荷問題|準備。~
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
で、並列計算。~
clusterApplyとは違い負荷分散を行っているため、各クラスターの待機状態がほとんどありません!~
 > st <- snow.time(sfClusterApplyLB(arg.sleep, Sys.sleep))
 > st
 elapsed    send receive  node 1  node 2  node 3  node 4 
    0.59    0.00   -0.02    0.45    0.52    0.53    0.60 
 > dev.new()
 > plot(st, title = "sfClusterApplyLB")
#ref(./sfClusterApplyLB.jpeg,50%)
:入出力負荷問題|今度は入出力負荷をかけた場合を見てみます。~
~
準備。~
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
 > fun.sleep <- function(x, ...) Sys.sleep(x)
 > arg.S <- NULL
 > arg.L <- numeric(10^7)
小さな引数を加えて並列処理を実行します。~
 > st.S <- snow.time(sfClusterApplyLB(arg.sleep, fun.sleep, arg.S))
 > st.S
 elapsed    send receive  node 1  node 2  node 3  node 4 
    6.01    0.00    0.02    6.00    5.20    5.30    4.51 
 > dev.new()
 > plot(st.S, title = "sfClusterApplyLB with SmallArg")
#ref(./sfClusterApplyLB with SmallArg.jpeg,50%)
続いて、大きな引数を加えて並列処理を実行します。~
負荷分散はされていますが、入出力負荷問題は残ったままです。~
 > st.L <- snow.time(sfClusterApplyLB(arg.sleep, fun.sleep, arg.L))
 > st.L
 elapsed    send receive  node 1  node 2  node 3  node 4 
   14.17   12.47    0.01    8.09    4.46    4.29    4.10 
 > dev.new()
 > plot(st.L, title = "sfClusterApplyLB with LargeArg")
#ref(./sfClusterApplyLB with LargeArg.jpeg,50%)
:総評|負荷分散がなされているものの、入出力負荷問題は依然として残る。~
また、馴染みの無い関数名なので、直接使うことは少ない。~
拡張するときの基礎となる関数なので、覚えといて損はない。~
**sfLapply・sfSapply・sfApply [#e9e1b3bc]
各apply familyを並列化したバージョンです。~
:概要|1.引数をクラスターの数に分割する。~
2.分割した引数をそれぞれのクラスターに引き渡す。~
3.計算結果の回収をする。~
:コーディング問題|snowfallなので、通常・並列の切り替えが容易。~
引数は通常関数と同じ。
:計算負荷問題|準備。~
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
で、並列計算。~
いままでのclusterApply系と異なり、まず4分割して一気に並列計算させるため~
入出力は各クラスターで1回のみとなっていることが分かります。~
ただし、負荷分散が行われていないため、計算時間はクラスター間でまちまちの状態です。~
 > st <- snow.time(sfLapply(arg.sleep, Sys.sleep))
 > st
 elapsed    send receive  node 1  node 2  node 3  node 4
    0.75    0.00    0.00    0.56    0.59    0.21    0.75
 > dev.new()
 > plot(st, title = "sfLapply")
#ref(./sfLapply.jpeg,50%)
:入出力負荷問題|今度は入出力負荷をかけた場合を見てみます。~
~
準備。~
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
 > fun.sleep <- function(x, ...) Sys.sleep(x)
 > arg.S <- NULL
 > arg.L <- numeric(10^7)
小さな引数を加えて並列処理を実行します。~
 > st.S <- snow.time(sfLapply(arg.sleep, fun.sleep, arg.S))
 > st.S
 elapsed    send receive  node 1  node 2  node 3  node 4
    0.75    0.00    0.00    0.56    0.59    0.20    0.75
 > dev.new()
 > plot(st.S, title = "sfLapply with SmallArg")
#ref(./sfLapply with SmallArg.jpeg,50%)
続いて、大きな引数を加えて並列処理を実行します。~
clusterApply系では1要素の計算ごとに引数を渡していたため、入出力の回数は要素数となりましたが~
Apply系では各クラスターで1回のみなので、clusterApply系に比べて早い結果となりました。~
 > st.L <- snow.time(sfLapply(arg.sleep, fun.sleep, arg.L))
 > st.L
 elapsed    send receive  node 1  node 2  node 3  node 4
    3.87    3.12    0.00    0.56    0.60    0.19    0.75
 > dev.new()
 > plot(st.L, title = "sfLapply with LargeArg")
#ref(./sfLapply with LargeArg.jpeg,50%)
:総評|各apply familyを並列化するため、入出力が1回で済むところがこの関数の特徴。~
一番簡単な並列化と言えるかもしれません。~
//######################################################################
**clusterMap [#rf031871]
hoge~
:概要|hogehoge~
:計算負荷問題|foo~
:入出力負荷問題|piyo~
:総評|bar~
これはmapplyを並列化したバージョンです。~
上記apply familyとは異なり、引数を分割して計算します。~
:概要|1.各クラスターに対して、1要素を渡す。~
2.全てのクラスターから計算結果を受け取ってから、各クラスターに次の1要素を渡す。~
3.その繰り返し。~
:コーディング問題|以下の理由でコーディングは問題です。~
・パッケージがsnowで、クラスターの指定をしなくてはならない。~
・クラスターの指定があるので、通常・並列の切り替えが容易ではない。~
・そもそもsnowfallではないので、扱いにくい。~
:計算負荷問題|準備。~
 > cl <- sfGetCluster()
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
//######################################################################
で、並列計算。~
グラフの形がclusterApplyにそっくりです。~
これはclusterMapの内部でclusterApply(正確にはstaticClusterApply)を使用しているためです。~
各クラスターの計算終了を待ってから次の計算に移るため、待機時間が発生しています。~
//######################################################################
 > st <- snow.time(clusterMap(cl, Sys.sleep, arg.sleep))
 > st
 elapsed    send receive  node 1  node 2  node 3  node 4 
    0.89    0.01    0.02    0.63    0.53    0.33    0.60 
 > dev.new()
 > plot(st, title = "clusterMap")
#ref(./clusterMap.jpeg,50%)
:入出力負荷問題|今度は入出力負荷をかけた場合を見てみます。~
~
準備。~
 > set.seed(0)
 > arg.sleep <- sample(1:20)/100
 > fun.sleep <- function(x, ...) Sys.sleep(x)
 > arg.S <- list(NULL)
 > arg.L <- list(numeric(10^7))
小さな引数を加えて並列処理を実行します。~
 > st.S <- snow.time(clusterMap(cl, fun.sleep, arg.sleep, MoreArgs = arg.S))
 > st.S
 elapsed    send receive  node 1  node 2  node 3  node 4 
    0.89    0.00    0.02    0.62    0.51    0.35    0.58 
 > dev.new()
 > plot(st.S, title = "clusterMap with SmallArg")
#ref(./clusterMap with SmallArg.jpeg,50%)
続いて、大きな引数を加えて並列処理を実行します。~
clusterApplyと同様に入出力負荷問題が発生しています。~
 > st.L <- snow.time(clusterMap(cl, fun.sleep, arg.sleep, MoreArgs = arg.L))
 > st.L
 elapsed    send receive  node 1  node 2  node 3  node 4 
   14.52   13.93   -0.01    0.60    0.51    0.38    0.60 
 > dev.new()
 > plot(st.L, title = "clusterMap with LargeArg")
#ref(./clusterMap with LargeArg.jpeg,50%)
:総評|コーディングにも問題があり、計算負荷分散もない、入出力負荷問題も残る。~
悪いことだらけだけど、小さな引数などでは早くなる可能性が残されている。~
//######################################################################
**sfMM [#n5986c79]
hoge~
:概要|hogehoge~
:計算負荷問題|foo~
:入出力負荷問題|piyo~
:総評|bar~
**sfClusterApplySR [#n5986c79]
hoge~
:概要|hogehoge~
:計算負荷問題|foo~
:入出力負荷問題|piyo~
:総評|bar~
*========== 上級編 : snowfallの拡張 ========== [#j3a0c47b]
*未実装関数の作成 [#sb5237df]
乏しい知識ですが、未実装関数を作成してみました。~
バグや誤りなど、お気づきの点がありましたら、指摘・加筆・修正のご協力をお願いいたします。~
**lapply [#wf95c0a5]
**sapply [#e1fc0386]
**apply [#pe00b9cb]
**mapply [#qb948e44]
**replicate [#p2490028]
**%*% [#l9668d10]
**sfet.set.seed [#e37a65f8]
 01  > clusterSetupRNG
 02  function (cl, type = "RNGstream", ...) 
 03  {
 04      RNGnames <- c("RNGstream", "SPRNG")
 05      rng <- pmatch(type, RNGnames)
 06      if (is.na(rng)) 
 07          stop(paste("'", type, "' is not a valid choice. Choose 'RNGstream' or 'SPRNG'.", 
 08              sep = ""))
 09      type <- RNGnames[rng]
 10      if (rng == 1) 
 11          clusterSetupRNGstream(cl, ...)
 12      else clusterSetupSPRNG(cl, ...)
 13      type
 14  }
 15  <environment: namespace:snow>

 01  > sfClusterSetupRNGstream
 02  function (seed = rep(12345, 6), ...)
 03  {
 04      sfCheck()
 05      if (sfParallel())
 06          clusterSetupRNGstream(sfGetCluster(), seed = seed, ...)
 07      else {
 08          warning(paste("Uniform random number streams (currently) not available in serial execution.",
 09              "Random numbers may differ in serial & parallel execution."))
 10          set.seed(seed[1])
 11      }
 12  }
 13  <environment: namespace:snowfall>

 01  > clusterSetupRNGstream
 02  function (cl, seed = rep(12345, 6), ...)
 03  {
 04      if (!require(rlecuyer))
 05          stop("the `rlecuyer' package is needed for RNGstream support.")
 06      .lec.init()
 07      .lec.SetPackageSeed(seed)
 08      nc <- length(cl)
 09      names <- as.character(1:nc)
 10      .lec.CreateStream(names)
 11      states <- lapply(names, .lec.GetStateList)
 12      invisible(clusterApply(cl, states, initRNGstreamNode))
 13  }
 14  <environment: namespace:snow>

 01  > .lec.SetPackageSeed
 02  function (seed = rep(12345, 6))
 03  {
 04      if (!exists(".lec.Random.seed.table", envir = .GlobalEnv))
 05          .lec.init()
 06      seed <- .lec.CheckSeed(seed)
 07      .Call("r_set_package_seed", as.double(seed), PACKAGE = "rlecuyer")
 08      return(seed)
 09  }
 10  <environment: namespace:rlecuyer>

 01  > .lec.CheckSeed
 02  function (seed)
 03  {
 04      ll <- length(seed)
 05      if (ll < 6) {
 06          tmpseed <- 12345
 07          seed <- c(seed, rep(tmpseed, 6 - ll))
 08      }
 09      if (ll > 6) {
 10          seed <- seed[1:6]
 11          warning("Seed may not exceed the length of 6. Truncated to ",
 12              paste(seed, collapse = ", "))
 13      }
 14      return(seed)
 15  }
 16  <environment: namespace:rlecuyer>

クラスターへの乱数設定のために、以下の関数が用意されています。~
 sfClusterSetupRNG
 sfClusterSetupRNGstream
でも、役に立たない。(と感じています。)~
~
試しに2CPUsで。
 > sfInit(TRUE,2)
 snowfall 1.84-6 initialized (using snow 0.3-13): parallel execution on 2 CPUs.
乱数を初期化。
 > sfClusterSetupRNG()
 [1] "RNGstream"
 > sfClusterCall(runif,5)
 [[1]]
 [1] 0.1270111 0.3185276 0.3091860 0.8258469 0.2216299
 
 [[2]]
 [1] 0.75958186 0.97831057 0.68513581 0.27926960 0.09942954
もう一回初期化。
 > sfClusterSetupRNG()
 [1] "RNGstream"
 > sfClusterCall(runif,5)
 [[1]]
 [1] 0.1270111 0.3185276 0.3091860 0.8258469 0.2216299
 
 [[2]]
 [1] 0.75958186 0.97831057 0.68513581 0.27926960 0.09942954
おんなじやん。使えん。~
~
まぁ、sfClusterSetupRNGで使用しているclusterSetupRNGstreamの中身が~
 clusterSetupRNGstream (cl, seed=rep(12345,6), ...)
なので~、いつも同じseed値が使われるので当たり前の結果ですね。~
しかも、set.seedのように引数にNULL値を入れて、再初期化(re-initializes)することが出来ません。~
~
■検証中■
 sfSet.Seed <- function(seed){
     snowfall:::sfCheck()
     seed.alt <- runif(6, -.Machine$integer.max, .Machine$integer.max)
 
     if (sfParallel()) {
         if (is.null(seed)) {
             sfClusterSetupRNGstream(seed.alt)
             invisible(NULL)
         } else {
             sfClusterSetupRNGstream(seed)
             invisible(NULL)
         }
     } else {
         set.seed(seed)
         invisible(NULL)
     }
 }
 
 sfSet.Seed(NULL);sfClusterCall(runif,5)
*Tips [#afc89819]
*========== その他 ========== [#k05eea73]
*参考文献・文書など [#y9d67e38]
-DOCUMENT
 help(package=snow)
 help(package=snowfall)
 vignette("snowfall")
-CRAN~
[[CRAN Task View: High-Performance and Parallel Computing with R:https://cran.r-project.org/web/views/HighPerformanceComputing.html]]~
-書籍~
[[Parallel R (英語):http://www.amazon.co.jp/Parallel-R-Q-Ethan-McCallum/dp/1449309925]]~
-rjpwiki~
[[Rで並列計算]]~
[[L. Tierney氏のsnowパッケージでクラスタ計算を行う]]~
[[Tierney 氏の R バイトコンパイラー]]~
[[Rコード最適化のコツと実例集]]~
[[Rの関数定義の基本]]~
-Web Page~
[[snow Simplified:http://www.sfu.ca/~sblay/R/snow.html]]~
[[Easier Parallel Computing in R with snowfall and sfCluster:http://journal.r-project.org/archive/2009-1/RJournal_2009-1_Knaus+et+al.pdf]]~
[[Tutorial Parallel computing using R package snowfall:http://www.informatik.uni-ulm.de/ni/staff/HKestler/Reisensburg2009/PDF/snowfall-tutorial.pdf]]~
[[Simple Network of Workstations for R:http://homepage.stat.uiowa.edu/~luke/R/cluster/cluster.html]]~
[[並列プログラミング入門(OpenMP編):http://www.hpci-office.jp/invite2/documents2/openmp_2014-11-25.pdf]]~
[[snowパッケージで並列化(R):https://sites.google.com/site/scriptofbioinformatics/bing-lie-hua-guan-xi/snowpakkejide-bing-lie-hua-r]]~
[[【R言語】ループ処理回避 (and/or) 並列化処理 組み合わせで、計算高速化 手法まとめ:http://qiita.com/HirofumiYashima/items/18d5aa87578115215230]]~
[[Rのちょっと速いコードの書き方:http://www.anlyznews.com/2012/02/r_11.html]]~
[[R の apply 徹底解説:http://d.hatena.ne.jp/a_bicky/20120425/1335312593]]~
*コメント [#xbb81a29]
#comment(below)
- とりあえずページを立ち上げました。 -- [[markovchainmontecarlo]] &new{2015-09-26 (土) 09:14:04};~
&counter;//20151006


トップ   新規 一覧 検索 最終更新   ヘルプ   最終更新のRSS