Rのループ（for）がなぜ遅いか？ 並列化によってどれくらい早くなるか？ （どういった場合に早くなるか） を調べて勉強会で発表した資料になります。

1. Rやってみた
〜高速化編〜

2. 自己紹介
 約４０年前 大阪に誕生
 約２０年前 大学にてニューラルネットワーク＆最適化
 約１５年前 開発会社にて各種開発を５年くらい
 約１０年前 現在（コンピュータ業界の）インフラ屋
 趣味
 ３DCG
 プログラミング（主にAndroid)
 統計学はド素人、Rは素人

3. 前回、Rを触ってみて結構面白かった
おやすみ
おはよう
個人的に
おっぱい
グラフからの推測
• ７時頃に起きる人が多い
• ０時頃に寝る人が多い
（寝る時間も時間に左右される）
→時計に縛られる日本人
・煩悩は夜に宿る ← new!

4. まじめにテーマを考える
 前回、前々回も出ていたモテモテのテーマ、それは…
高速化！
• 前半…“遅い”の詳細
• 後半…高速化

5. R業界の嫌われ者といえば「for」
 「forを使うな…」
 「forは遅い」
 「forは…」
どのページを見てもforの悪口だらけ
なぜ遅い？

6. エクセレントコード ウンコード
そもそもなぜfor文が遅いか？
 「ベクトルa」の平方根を「ベクトルb」に代入
OS
R
for(i in 1:10^6) b[i]<-sqrt(a[i])
関数
Rインタプリタ
OS
R
b<-sqrt(a)
関数
Rインタプリタ
ユーザ システム 経過
0.001 0.001 0.001
ユーザ システム 経過
16.440 7.205 23.681
という“推測”

7. 推測を確認する
 Rでは処理時間の詳細（プロファイル）を調べる「Rprof()」を用いる
エクセレントコード ウンコード
> a <- c(1:10^7)
> Rprof()
> for( i in 1:1) b <- sqrt(a)
> Rprof(NULL)
> summaryRprof()
$by.total
total.time total.pct self.time self.pct
"sqrt" 0.18 100 0.18 100
> a <- c(1:10^5)
> b <- c()
> Rprof()
> for( i in 1:length(a)) b[i] <- sqrt(a[i])
> Rprof(NULL)
> summaryRprof()
$by.total
[1] total.time total.pct self.time self.pct
<0 行> (または長さ 0 の row.names)
R上では原因を観測できない
バグ？
→0.02秒間隔では検出不可（Rprof.out)

8. （ドつぼにはまっているが）
推測を「本腰入れて」確認する
 これ以上詳細を調査しようとすると
1. Rから詳細なログを出力して動きを追う
2. Rより下のレイヤから動きを追う
Instruments（プロファイルツール）

9. 想像を本腰入れて確認する
〜エクセレントコード〜
a <- c(1:10^7)
for( i in 1:1) b <- sqrt(a)
ポイントは、平方根を取る目的の処理が
84%(262ms)の時間を使っているところ

10.  arithmetic.c
想像を本腰入れて確認する
do_math1の正体
SEXP attribute_hidden do_math1(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP s;
checkArity(op, args);
check1arg(args, call, "x");
if (DispatchGroup("Math", call, op, args, env, &s))
return s;
if (isComplex(CAR(args)))
return complex_math1(call, op, args, env);
#define MATH1(x) math1(CAR(args), x, call);
switch (PRIMVAL(op)) {
case 1: return MATH1(floor);
case 2: return MATH1(ceil);
case 3: return MATH1(sqrt);
case 4: return MATH1(sign);
math関数呼び出し
/* Mathematical Functions of One Argument */
static SEXP math1(SEXP sa, double(*f)(double), SEXP lcall)
{
SEXP sy;
double *y, *a;
R_xlen_t i, n;
int naflag;
if (!isNumeric(sa))
errorcall(lcall, R_MSG_NONNUM_MATH);
n = xlength(sa);
/* coercion can lose the object bit */
PROTECT(sa = coerceVector(sa, REALSXP));
PROTECT(sy = allocVector(REALSXP, n));
a = REAL(sa);
y = REAL(sy);
naflag = 0;
for (i = 0; i < n; i++) {
if (ISNAN(a[i]))
y[i] = a[i];
else {
y[i] = f(a[i]);
if (ISNAN(y[i])) naflag = 1;
}
}
ここでSQRT処理

11. 想像を本腰入れて確認する
〜ウンコード〜（２時間でギブアップ）
a <- c(1:10^7)
b <- c()
for( i in 1:10^7) b[i] <- sqrt(a[i])
このVectorAssignが99%の時間
を食っている
平方根を取る処理が
0.1%未満！

12. 想像を本腰入れて確認する
〜ウンコード〜
a <- c(1:10^7)
b <- numeric(10^7)
for( i in 1:10^7) b[i] <- sqrt(a[i])
7,321,955ms(以上)から
31,276msへ改善！
事前に領域確保
平方根を取る目的の処理が
3,886ms(以上) から 2,159msに改善

13. for文は遅いのまとめ
 For文で処理をまわすなら迷わず領域を事前確保するべき
（２時間以上 → ３０秒）
 領域を事前準備した場合
全体では約100倍の差
メインの処理（sqrt）の時間は約8倍の差
→内部の処理が時間差のほとんどを占める
全体（ms） math1 その他 備考
エクセレントコード 305 262 48
ウンコード 31,276 2,159 29,117 10^7回ループ
10^7回のループで
10^2の処理時間
は許容範囲

14. ここから
今回のメインテーマ

15. ベクトル化できない場合
そんなときは…
 アルゴリズム、プログラムの工夫
 並列化（複数スレッドを使用する）
 並列化（複数マシンを使用する）
 GPU並列化 変態向け
賢い人向け
玄人向け
マニア向け
色々ありそうなのでパス
対応関数が少ない

16. 並列化（環境と動作イメージ）
 今回は４ノードを準備
Switch
ssh
① ノードでRを起動する。
② クラスタノードを指定する。
③ 並列化処理を実行
R
R
R
R
R
R
R
R
R
R
R
R
R
R R
R
④ 各ノードで指定された数だけRプ
ロセスを起動して処理
⑤ 結果を元のRに集約
・Xeon(R) CPU E31220
（4コア、3.10GHz）
・メモリ 16GB

17. 並列化（Rでの書式）
① ノードでRを起動する。
② クラスタノードを指定する。
③ 並列化処理を実行
④ 各ノードで指定された数だけR
プロセスを起動して処理
⑤ 結果を元のRに集約
① ターミナルにて「r」を実行
② cl <- makeCluster(c(“サーバ名”,〜略〜), type = “SOCK”)
registerDoSNOW(cl)
③ foreach(i = 1:1000) %dopar% { sum(rnorm(10000)) }
④ ※ライブラリがやります
⑤ ※ライブラリがやります

18. 並列化（使用するパッケージ）
以下のパッケージを使うことで別ノードを使用した並列化を容易に実
現
（すべてのノードにパッケージを事前にインストール）
 snow ・・・ Simple Network of Workstations
 foreach ・・・ for文を並列化する
 Iterators ・・・ 展開
 doSNOW ・・・ snowの簡易化（registerDoSNOW関数のみ）
単一ノード（スレッド）と複数ノードを
同じ様に扱うことができる

19. 並列化評価
気になる２つのポイント
 並列化は本当に早くなるの？
 ネットワークはボトルネックにな
らないの？
Switch
ssh
R
R
R
R
R
R
R
R
R
R
R
R
R
R R
R
ボトル
ネック？
転送データ 小／大
処理時間 短／長

20. 並列化（転送データ 小、処理時間 短）
 乱数ベクトルの合計を求める
system.time(for( i in 1:10^3 ) sum(rnorm(10^5)))
ユーザ システム 経過
8.486 0.000 8.483
単一プロセス
cl <- makeCluster(c("localhost”…), type = "SOCK")
registerDoSNOW(cl)
system.time(
foreach(i = 1:10^3) %dopar%{
sum(rnorm(10^5)) })
stopCluster(cl)
並列化
0
2
4
6
8
10
12
14
16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
時間（秒）
並列度
並列度と処理時間（５回平均）
処理時間
7.1倍の高速化！

21. 並列化（転送データ 小、処理時間 長）
 乱数ベクトルの合計を求める
system.time(for( i in 1:10^2 ) sum(rnorm(10^7)))
ユーザ システム 経過
84.372 0.576 85.008
単一プロセス
cl <- makeCluster(c("localhost”…), type = "SOCK")
registerDoSNOW(cl)
system.time(
foreach(i = 1:10^2) %dopar%{
sum(rnorm(10^7)) })
stopCluster(cl)
並列化
10^3から
変更
10^5から
変更
約10倍
0
10
20
30
40
50
60
70
80
90
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
時間（秒）
並列度
並列度と処理時間（５回平均）
処理時間
13.2倍の高速化！

22. 「転送データ 大」の準備
 大きなデータの代表、画像データを処理しよう！
画像処理業界でおなじみ
の「Lena」たん
自主規制
（続きはWebで！）
Width:1084
Height:2318

23. Rで画像処理ってどういうこと？
 色を減らす「減色処理」に使える。
クラスター分析じゃない？RGB空間を色の数で分割
元画像 減色画像

24. 並列化（転送データ 大、処理時間 短）
対象：LENAフル画像
処理：ランダムな点を返す
自主規制！
Width:1084
Height:2318
system.time(for(i in 1:10^3)
myimage[floor(runif(1,1,MAX_VALUE))])
ユーザ システム 経過
0.02 0.00 0.03
単一プロセス
cl <- makeCluster(c("localhost”…), type = "SOCK")
registerDoSNOW(cl)
system.time(
foreach(i = 1:num,.export=c(“myimage”,“MAX_VALUE”))
%dopar% myimage[floor(runif(1,1,MAX_VALUE))])
stopCluster(cl)
並列化
character vector of
variables to export.
0
2
4
6
8
10
12
14
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
時間（秒）
並列度
並列度と処理時間（５回平均）
処理時間

25. 0
1000
2000
3000
4000
5000
6000
7000
8000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
時間（秒）
並列度
並列度と処理時間
処理時間
並列化（転送データ 大、処理時間 長）
対象：LENAフル画像
処理：k-meansで減色
自主規制！
Width:1084
Height:2318
for(i in 1:16)
kmeans(myimage2,centers=255,iter.max=10,nstart=i)
ユーザ システム 経過
0.02 0.00 ２時間以上
単一プロセス
ret_better <- function(x,y) {
if (x$tot.withinss < y$tot.withinss) x
else y
}
res_kmean <- foreach(i =
1:16,.combine="ret_better") %dopar%{
kmeans(myimage2,centers=255,iter.max=50,nstart=i)
}
並列化

26. 減色例
元画像（フルカラー） 画像アプリ減色（256色） R減色（256色）
注：時間は数十倍、数百倍かかっています

27. 高速化検証のまとめ
 やっぱりベクトル化した処理が早い
 for文使うときは事前に領域を準備することにより高速化
(個人的な感覚としては、なるべくforはさけた方がよいレベル）
 繰り返し処理はforeachを用いた並列化を積極的におすすめ！
 マルチコアマシンで容易に並列化
 マルチノードでも容易に並列化
 大きなデータは遅くなる場合がある
→処理が長ければ許容できる
転送データ量
大 小
処
理
時
間
長 ◎ ◎
短 × ○ぜひ、並列化を！

28. 付録

29. 並列化（転送データ 小、処理時間 中）
 コラッツの問題(未解決問題）
以下を繰り返すとどんな
値も１に集約する
・偶数なら２で割る
・奇数なら３を掛け１を足す
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
5
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
時間（秒）
並列度
並列度と経過時間(5回平均)
経過時間

30. ちなみに、コラッツの問題のグラフ化
 X軸方向に初期値、Y軸方向に繰り返し回数

31. 付録（コラッツの問題）
do_cluster <- function(num=10^4, client_num=1){
cl <- makeCluster(c("localhost","localhost",中略,"Slave03")[1:client_num], type = "SOCK")
registerDoSNOW(cl)
ret = system.time(foreach(i = 1:num,.combine = "cbind") %dopar% {
n <- i
while(n != 1){
if( n %% 2 == 0 ) n <- n / 2
else n <- 3 * n + 1
}
})
stopCluster(cl)
ret
}
rm(ret)
test_count <- 15
ret <- c()
for (i in 0:test_count) ret <- cbind(ret,do_cluster(num=10^3, client_num = (i%%16)+1))

32. 付録（減色処理）
library("biOps”)
myimage <- readJpeg("l_hires.jpg")
myimage2 <- matrix(myimage,ncol=3)
HEIGHT <- dim(myimage)[1]
WIDTH <- dim(myimage)[2]
ret_better <- function(x,y) {
if (x$tot.withinss < y$tot.withinss) x
else y
}
registerDoSNOW(makeCluster(2, type = "SOCK"))
res_kmean <- foreach(i = 1:30,.combine="ret_better") %dopar%{
kmeans(myimage2,centers=255,iter.max=50,nstart=i)
}
plot(imagedata(c(res_kmean$centers[res_kmean$cluster,]),type="rgb",ncol=HEIGHT,nrow=
WIDTH))