編集履歴

質問編集履歴

シングルスレッドプログラミングでの順次的記述方法を追加＋マルチコアに対する考察の追加

2016/10/31 23:58

投稿

mit0223

スコア3401

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -118,9 +118,205 @@
-* 補足：マルチコアについて
-一つは、それほど性能がCPUに依存するアプリが少ないというのがありますが、CPU依存が強い場合でも複数のシングルスレッドプロセスにロードバランサなどで負荷分散することで、プログラム自身はシングルスレッド・協調的マルチタスクで書くことが可能だと思います。
+####補足1：マルチコアについて
+それほど性能がCPUに依存するアプリが少ないのではないかとは思いますが、、CPU依存が強い場合でもワーカプロセスに負荷分散することで、プログラム自身はシングルスレッド・協調的マルチタスクで書くことが可能だと思います。特に並列演算で問題が解決するような場合は、ワーカプロセス側で GPUをつかったり、SIMD命令を使うなど、マルチコア以上に並列度をあげる工夫が必要ではないかと考えます。この場合は、マルチスレッドプログラミングというよりも並列処理プログラミングになってくると思います。となると、やはりマルチスレッドプログラミングは不要なのではないかと思えてきます。
+####補足２：イベント駆動型プログラミングの順次的記述
+回答でイベント駆動型プログラミングのデメリットとしてサブルーチンのネスト構造などモジュール化がやりにくいという指摘がありました。 Javascript では、サブルーチンの呼び出し後の継続処理をコールバック関数（というかクロージャ）に記述するという技法で回避し、非同期でありながらモジュール化を行うことに成功しています。しかし、この技法はコールバック地獄と呼ばれており、モジュール化には成功しましたが、順次処理を記述すると、ネストがどんどん深くなるという欠点がありました。次世代 Javascript である es6 では、この問題を Promise という技法でさらに回避しております。
+ここで、普通に順次的に記述したプログラムと Promiseを使って非同期処理可能でありながら順次的に記述したプログラムを比較してみます。
+普通の順次的記述
+```Javascript
+function main() {
+  let x = 'default value of x';
+  let y = 'default value of y';
+  let z;
+  try {
+    z = getValuesForZ(x);
+    z = z.map(item => processItem(item));
+    if (z.includes(processItem(x))) {
+      y = processY(y);
+    }
+    console.log("x = " + x + ", y= " + y + ", z= " + z);
+  } catch (e) {
+    console.log(e);
+  }
+}
+function getValuesForZ(arg)
+{
+  return ['value1', 'value2'].concat(arg);
+}
+function processItem(item) {
+  return 'processed:' + item;
+}
+function processY(y) {
+  return processYnest(y);
+}
+function processYnest(y) {
+  return 'processed in nested function:' + y;
+}
+main()
+```
+Promise を使った非同期処理可能な順次的記述
+```Javascript
+function main() {
+  Promise.resolve({
+    x: 'default value of x',
+    y: 'default value of y'
+  })
+  .then(getValuesForZ())
+  .then(state => {
+    return Promise.all(state.z.map(item => Promise.resolve(item).then(processItem())))
+      .then(z => Object.assign(state, {z}));
+  })
+  .then(state => {
+    return Promise.resolve(state.x).then(processItem()).then(r => {
+      if (state.z.includes(r)) {
+          return Promise.resolve(state).then(processY());
+      }
+      return state;
+    });
+  })
+  .then(state => {
+    console.log("x = " + state.x + ", y= " + state.y + ", z= " + state.z);
+  })
+  .catch(e => {
+    console.log(e);
+  });
+}
+function getValuesForZ()
+{
+  return state => Object.assign(state, {z:['value1', 'value2'].concat(state.x)});
+}
+function processItem() {
+  return item => 'processed:' + item;
+}
+function processY() {
+  return state => {
+    return Promise.resolve(state.y)
+      .then(processYnest())
+      .then(y => Object.assign(state,{y}));
+    };
+}
+function processYnest() {
+  return y => 'processed in nested function:' + y;
+}
+main()
+```
+普通版は 34行に対して、Promise 版は48行と行数は増えてしまいましたが、処理順にプログラムを書くことができて、かつ、サブルーチンによるモジュール化もできていると思います。
+モジュール化のみそは、サブルーチンが演算結果を返すのではなく、演算を行う関数を返すことです。このようにすることで、呼び出し側は非同期にその関数を呼び出すことができるわけです。
+プログラムの詳細な説明は避けますが、順次処理、条件判定、繰り返し処理、サブルーチンのネスト呼び出しを含める例となっています。プログラムの処理内容には何の意味もありません。また、両方を比較しやすいように非同期処理は入っていませんが、Promise版の方ではいくらでも非同期処理を挿入できますが、普通版では非同期処理を挿入することは不可能です。

論点をシングルスレッドプログラミングに変更

2016/10/31 23:58

投稿

mit0223

スコア3401

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -28,17 +28,99 @@
 ####協調的マルチタスク派
-私は個人的にはイベント駆動型が好きで、性能問題でマルチスレッド派を駆逐して欲しいくらいに思っています。そもそも、長時間の処理に入るのに、何時間かかるか予想もつかず、中断もできないようなプログラムの存在が良くないと思います。すべてのプログラムはそのユースケースに応じて、時間がかかりすぎる場合には中断できるとか、かかる時間を予測して途中経過を報告する機能が具備されているべきだと思います。それで、そのような機能を実装しようとすると、スレッドで割り込みを気にしながら順次的に書くよりも自分で状態遷移を管理するほうが簡単ではないでしょうか。
+（いくつか回答いただいて、自分の好みの問題とC10K問題が直結していないことに気が付き、書き直しました）
+私は個人的にはシングルスレッドイベント駆動型でコーディングするのが好きで、c10K問題を理由にマルチスレッドプログラミングのパラダイムを駆逐して欲しいくらいに思っています。たとえば、DBへの問い合わせが長い時間かかる場合に、ユーザからの要求やシステムのシャットダウンに対応して問い合わせを中断できるようにする場合、マルチスレッドで割り込みを気にしながら順次的に書くよりも自分で状態遷移を管理するほうが簡単ではないでしょうか。マルチスレッドの場合、
+（DBへの問い合わせを中止できるようなドライバがあるかどうかはおいておいて）
-####質問：どっちが好きですか・どっちが勝つと思いますか
+```javascript
-JavaScript のコールバックは嫌いですか？ lua などコルーチンの yield って懐かしくないですか？
+class 問い合わせ {
-みなさんはどちらが好きですか？どちらが勝つと予想しますか？
+  do() {
+    try {
+      DBへの問い合わせ
+    } catch (CancelSignal cs) {
+      if (微妙なタイミング判定) {
+        問い合わせ中止処理
+      }
+    }
+  }
+  onCancel() {
+    問い合わせ実行中スレッドへ CancelSignal を送信
+  }
+}
+```
+となり、問い合わせの終了とキャンセルシグナルの入力との微妙なタイミング判定（排他制御）が必要ですが、シングルスレッドであれば、
+```javascript
+class 問い合わせ {
+  do() {
+    DBへの問い合わせ((event) => this.handler(event));
+  }
+  handler (event) {
+    ...
+  }
+  onCancel() {
+    問い合わせ中止処理
+  }
+}
+```
+と書けて、シングルスレッドなので、handler 呼び出しと onCancel の呼び出しは早い者勝ちとなるわけです。
+そもそも、OSレベルでは多重入力はイベント駆動で実装されているわけで、そのイベント駆動をそのままコーディングできるシングルスレッドイベント駆動プログラミングって気持ち良くないですか？
-そもそもこの問題提起自身正しいと思いますか？
+####質問：シングルスレッドプログラミングは好きですか？残ると思いますか？
+いくつか回答いただいて、シングルスレッドプログラミングとC10K問題が直結していないことに気が付きましたが、質問としてはC10K問題で復権したシングルスレッドプログラミングをどう思うかというポイントに変更して続けさせていただきたいと思います。
+JavaScript のコールバックは嫌いですか？ lua などコルーチンの yield って懐かしくないですか？マルチスレッドプログラミングって難しくないですか？
+* 補足：マルチコアについて
+一つは、それほど性能がCPUに依存するアプリが少ないというのがありますが、CPU依存が強い場合でも複数のシングルスレッドプロセスにロードバランサなどで負荷分散することで、プログラム自身はシングルスレッド・協調的マルチタスクで書くことが可能だと思います。

typo修正

2016/10/30 00:18

投稿

mit0223

スコア3401

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -22,7 +22,7 @@
 前述の昔話において、パソコンのOSがプリエンプティブマルチタスクに置き換えられるときも、OSの実装者は「プリエンプティブマルチタスクなんて必要ない。プログラマが時間のかかる処理を実装するときに処理の途中経過を報告したり、中断したりする機能をちゃんと入れてれば、協調的マルチタスクのほうが効率が高いに決まっている」と執拗に粘ったのですが、世の中の流行には逆らえず（というよりも質の悪いプログラムの多さに負けて）、負けてしまいました。
-今回もプリエンプティブマルチタスク（マルチスレッド派）対協調的マルチタスク（イベント駆動型やコルーチン派）の戦いが始まっているように思います。これを第二次プリンティブ戦争と呼びましょう。
+今回もプリエンプティブマルチタスク（マルチスレッド派）対協調的マルチタスク（イベント駆動型やコルーチン派）の戦いが始まっているように思います。これを第二次プリエンプティブ戦争と呼びましょう。

スレッド/リクエストによるc10k についての情報を追加

2016/10/29 11:15

投稿

mit0223

スコア3401

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -18,7 +18,7 @@
 ####また戦いが
-その状況の中で、最近のWebでの議論を見ていると、Linux のマルチスレッドが非常に軽量・高速で協調的マルチタスクじゃなくてもマルチスレッドで十分性能が出るというベンチマーク結果が出てきているようです。そうなると、協調的マルチタスクの処理系はまたなくなってしまうのでしょうか。
+その状況の中で、最近のWebでの議論を見ていると、Linux のマルチスレッドが非常に軽量・高速で協調的マルチタスクじゃなくてもマルチスレッドで十分性能が出るというベンチマーク結果が出てきているようです（※１）。そうなると、協調的マルチタスクの処理系はまたなくなってしまうのでしょうか。
 前述の昔話において、パソコンのOSがプリエンプティブマルチタスクに置き換えられるときも、OSの実装者は「プリエンプティブマルチタスクなんて必要ない。プログラマが時間のかかる処理を実装するときに処理の途中経過を報告したり、中断したりする機能をちゃんと入れてれば、協調的マルチタスクのほうが効率が高いに決まっている」と執拗に粘ったのですが、世の中の流行には逆らえず（というよりも質の悪いプログラムの多さに負けて）、負けてしまいました。
@@ -39,3 +39,13 @@
 みなさんはどちらが好きですか？どちらが勝つと予想しますか？
 そもそもこの問題提起自身正しいと思いますか？
+※１の参考：
+[TCP/IP - Solving the C10K with the thread per client approach](http://stackoverflow.com/questions/17593699/tcp-ip-solving-the-c10k-with-the-thread-per-client-approach)
+[「サーバ書くなら epoll 使うべき」は、今でも正しいのか](http://developer.cybozu.co.jp/archives/kazuho/2009/09/epoll-bac0.html)
+いずれも、協調的マルチタスクに比べれば性能は出ないと思いますが、「協調的マルチタスクがないと１万コネクションはできないのかというとそうではない」という主張だと思います。桁が上がって１０万コネクションになれば、やはり協調的マルチタスクが必要なのかもしれません。