マルチスレッドプログラミング相談室 その9YouTube動画>1本 ->画像>1枚

マルチスレッドプログラミングについて語るスレ

■前スレ
マルチスレッドプログラミング相談室 その8
http://toro.2ch.net/test/read.cgi/tech/1253521167/

■過去スレ
その１ http://pc3.2ch.net/tech/kako/997/997345868.html
その２ http://pc5.2ch.net/test/read.cgi/tech/1037636153/
その３ http://pc8.2ch.net/test/read.cgi/tech/1098268137/
その４ http://pc8.2ch.net/test/read.cgi/tech/1130984585/
その５ http://pc11.2ch.net/test/read.cgi/tech/1157814833/
その６ http://pc11.2ch.net/test/read.cgi/tech/1187008532/
その７ http://pc12.2ch.net/test/read.cgi/tech/1215253576/

OS・言語・環境は問わないが、それゆえ明記すべし。
テンプレ
【ＯＳ】
【言語】
【実行環境】
【その他特記する事項】

■関連スレ・関連性の高いスレ

ネットワークプログラミング相談室 Port28
http://toro.2ch.net/test/read.cgi/tech/1334736934/

>>1 乙

前スレ >>994
並列実行「可能」でも「スケールする」かは知らんぞ。

OpenMP なら !$omp parallel do としてコンパイルオプション /Qopenmp

>>前すれ995
そういうオプションがあるのですね，レポートと書き直したソースを添付します．

http://www5.puny.jp/uploader/download/1339744079.zip
pass:giko

potential OUTPUT 依存関係
らしいですが，ググってもよくわかりません．依存関係がないように>>前すれ999のようにpureに書き換えたのですが．

>>前すれ997
これは試しにつけてみただけのものです，やはり使い方が違いますか・・．

gfortran -O3 20120528_fast_pararell_subroutine.f90 -ftree-vectorize -msse2 -ftree-vectorizer-verbose=2

彼女二人と同時にデートする時はマルチスレッドじゃないといけないんだけど
どうすればいいかな

時分割でがんばれ

Analyzing loop at 20120528_fast_pararell_subroutine.f90:237
237: not vectorized: not suitable for gather D.2660_224 = *shoi_69[D.2659_223];
Analyzing loop at 20120528_fast_pararell_subroutine.f90:196
196: not vectorized: not suitable for gather D.2600_148 = *a_147(D)[D.2599_146];
Analyzing loop at 20120528_fast_pararell_subroutine.f90:150
150: not vectorized: loop contains function calls or data references that cannot be analyzed
Analyzing loop at 20120528_fast_pararell_subroutine.f90:131
131: not vectorized: not suitable for gather D.2767_169 = *a_86(D)[D.2766_168];
Analyzing loop at 20120528_fast_pararell_subroutine.f90:91
91: not vectorized: not suitable for gather D.2704_87 = *a_86(D)[D.2703_85];
Analyzing loop at 20120528_fast_pararell_subroutine.f90:37
37: not vectorized: not suitable for gather D__I_lsm.780_635 = MEM[(real(kind=8)[0:] *)D.2433_241][pretmp.758_17];
Analyzing loop at 20120528_fast_pararell_subroutine.f90:38
38: not vectorized: not suitable for gather D.2485_318 = MEM[(real(kind=8)[0:] *)D.2298_95][D.2484_317];

>>4
ループ間で出力変数に依存関係があるかも、という判断。

○ i, j は value 属性を付け、b は戻り値にする。
○ サブルーチン inv の宣言部に interface で sho_det の引数属性を書く。

ここまでで依存はクリア、反復回数が少ないかも、というようになる。
/Qpar-threshold0 オプション (100〜0) で並列化は完了。

bに依存がないことくらい解析できてもよさそうなのにね

sho_det呼び出しの２重ループで並列化できるの？

双子と付き合う時はマルチスレッドのチンポ子が欲しい。

クリティカルセクションとかミューテクスって重いんですか？
秒間2500回とかマジキチですか？

400μ秒は今のパソコン環境でも、厳しいんじゃね
何をしたいかにもよるけど、専用環境作ったほうがハマらんかもね

ロックフリー！

>>13
そのあたりだと、API 呼び出しのオーバーヘッドもバカにならないから
自前で実装したほうがいいんじゃね？

https://gist.github.com/2841832
によれば
> Mutex lock/unlock 25 ns

>>13
重いけどそれくらいならいけると思う
できるならスレッドごとにリソースもって
最後に合体させたほうが速い

申し訳ありません，並列化ですが，解決しました．
/Qpar-threshold(並列化のしきい値)の値を100から20ぐらいまで下げたら5スレッドで実行されました．

ただ，ものすごく，計算が遅くなってしまって，なおかつ不必要なところまで並列化されてしまったようです．
このループだけ並列化したいっていうような指定ってできるのでしょうか？

>>17
Mutexってスレッド数によると思うんだけどな。
シングルコアならオンキャッシュで対応できるけど、
マルチコアだったりマルチCPUだったらメモリ参照と大差ないと思う。

答え教えてもらって、闇雲にやるのが今風なの？

それって、単純ループがスレッド化されただけじゃねえの？

実行環境に寄って自動で最適化して欲しいよね。
ちょっと違うけどjitみたいに自分でプロファイルとって実行処理罹る所を重点的に最適化とかさ。

4coreの環境と64coreの環境といちいち最適化するのめんどくさい。

core数増えたから、早くなるってわけでもないでしょうに

効率が悪かろうと並列化したいループには !DEC$ PARALLEL ALWAYS
※ 依存性に目をつぶれという指示ではない

> 64core の対応
３日かかる計算を１時間に押し込みたいなら、やる価値はある。
１分の処理が１秒になることを期待するなら、最適化する時間のほうが長い。

そもそも、大体の 64core での性能問題は 4core では小さくて見えないだけ。
スケールするとかしないとかはそういう話。

速くなってくれないと高額な多コア買った意味無いんだが。

それは、プログラム作ったベンダーに言え。
場合によっては、どれくらい高速化するかの見積もりくらい出してくれるだろ。

分散処理できるように考えるほうが難しいのに
道具によってはできることとできないことがあるでしょ

多コア化すれば、将来は、割込優先スレッド用コア、時分割スレッド用コア、OS用コアに別れて、それぞれのコアが空き時間でどうでもしてくれスレッドを処理するようになる気がする。
そうしないとスケジューリングに費やすコストが無駄だ。

あまり賢そうに見えないな

gpuが標準的になった時点で、非対称プログラミングが当たり前になるから、コア間に使い分け、役割分担が発生するのは必然じゃないかな。もっともどのコアがどの役割をやるかは、スケジューラが決めることになるけど。

標準的な入出力は動くコア決めたほうがいいかもしれんけど
プロセス、スレッドはどのコアで動こうが関係無いような
どうせ、暇な？コアに割り当てられるだろうから

linuxだとこういう指定が出来るようだ
http://linuxjm.sourceforge.jp/html/LDP_man-pages/man2/sched_setaffinity.2.html

それぐらいは WindowsNT 4.0 からあるが。

SetProcessAffinityMask
http://msdn.microsoft.com/ja-jp/library/cc429334.aspx

コア数とかうるさい割にapiのことは言わんのね？

pスレッドについて教えてください。


関係性のない処理を行う２つのスレッドＡ、Ｂを同時に動かし始めたいのですが、

・スレッドＡの待ち状態にpthread_cond_wait(&cond, &mutex1);

・スレッドＢの待ち状態にpthread_cond_wait(&cond, &mutex2);

として（condは同じで、mutexが異なる）、これらを動かし始めるために別スレッドで

pthread_cond_broadcast(&cond);

をコールしたのですが、思ったとおりに動いてくれません。
なにがいけないのでしょう？
（pthread_cond_wait()の使い方を間違えている？）

馬鹿には無理

>>36
broadcast を受ける側のスレッドは、 broadcast するときに wait していなければいけない
broadcast したときに wait しているスレッドがいなければ、無駄撃ちになる
通常 cond が mutex と一緒に使われるのは、ターゲットが wait に入る一瞬前に broadcast を撃って運悪く外れたりするような事態を回避し、確実に当たるようにするため
思ったとおりに動いてくれないというのなら、あなたの使い方には何か誤りがあって、そういった問題を防ぎ切れていないのだろう

>>38
素朴に待っていると思っていたスレッドが、実は待っていないせいで
シグナルがすり抜けていたということですね

このての、「関数を素朴に並べただけでは思いどおりに動作しない」問題の対応方法には
それぞれに決まった「お作法」「イディオム」がありそうな気がしますが、どうなんでしょう？


ともかく、ありがとうございました

>>39
pthreadの粒度が小さい場合、threadの実行順序がぐだぐだになるから要注意。
結論としては、充分長い処理でもない限りcond_waitは使えない。

>>40
頭で考えたアルゴリズムを実験するときに「安全装置」を省略したせいで
かんたんなこーどなのにはまるなんてありそうですね・・・・

自分が使いたい本番コードは、各スレッドの処理に十分なマスがあるので
素朴なつくりでもそれなりに動いたかもしれませんが、
再現性のないトラブルが発生する前にそういう問題を認識できてよかったです

ありがとうございました

>>41
去年の暮れ辺りに悩んでいたのが、mutexでスレッドプールを管理していたツールなんだよね。
mutexは相手がロックしていれば待つけど、相手がスケジュールはずされてロックしてくれていないと
自分が待たずにロックしちゃうことに。
メインスレッドでmutex_unlock(); mutex_lock()のように書いているのにunlockしたあと
lockするところまで実行できないなんてちょっと想像しにくいぞ。
# 詳細不明だけど、unlockした時点でプールスレッドがスケジュールされてメインスレッドがスケジュールからはずされるっぽい。

いつでもどんな時にでも
スケジュールから外されても動かされても
大丈夫なように作るのが鉄則

そうそう。
だから、Web上のサンプルは当てにならない。

そもそも並列化したいのは高速に処理したいからじゃん？
サンプルにかならずあるsleep()を消すと、途端にまともに動かなくなる
まともに動かなくなるならまだいいけど、「ときどき動作がおかしい」これ最悪

て言うかサンプルってそういうもんだし。

そもそも >>42 が

> mutexは相手がロックしていれば待つけど、相手がスケジュールはずされてロックしてくれていないと
> 自分が待たずにロックしちゃうことに。

って書いてるけど、それ以外にどんな動作を期待してるのか、よくよわからん。

マトが止まっていないとシグナルがすり抜けちゃうなんて最初はわかんないでしょ

そんなことより、マトがトマるだって・・・・・！喜ｗ

ﾀﾞﾚﾓｲﾅｲ・・・・・・ﾀﾞｼﾞｬﾚｵｿﾙﾍﾞｼ・・・・・


素朴なＱなんですが、マルチＣＰＵのマシンで、

�@ひとつのプロセスに属するスレッドは、全部同じＣＰＵ（プロセスがいる）で動く

�Aひとつひとつのスレッドが独立してＣＰＵを渡り歩いているように見えるのは、
　スレッド単体ではなく、それの属するプロセスが渡り歩いているため



こういう理解は正しいですか？

スレッドの割り当てとかはOSが決めてることだからね
OSの挙動に影響しないようなことを考えながらやりませう

マルチCPUじゃなく
単一CPUの時のスレッド等の挙動を考えてみませう

同じプロセッサ内のコアを移動するならまだしも、別のプロセッサに移動してしまったら、
せっかく溜め込んだキャッシュがおじゃんになってしまうのではないでしょうか？

逝ってるなマルチコアはCPU毎に命令データキャッシュ持ってるでしょ

でも分岐したらダメなのでは？

よく考えたら、分岐するんだったらＣＰＵ移らなくてもダメだった
ﾄﾞﾋﾟｭｯ

命令の先読みとかやってるの知ってる？

同じ領域を読み込む場合に早くなるってのがキャッシなのでは？

HDDキャッシュとかも同じでしょ

別のプロセッサに移動してしまったらキャッシュとかおじゃんになってしまうかもしれないが、
ひとつのプロセッサに多数のスレッドが集中して別のプロセッサを遊ばせておくくらいならいくつかのスレッドを移した方がいい場合もある
OSの裁量次第

キャッシュ知らんでも
スレッド系のプログラム作るのには関係無いような

速度ウンタラは動いてから考えればいい話でしょ

初心者の質問です

new;した領域 p があって
スレッドAは条件によってdelete p;をする
スレッドBはpを参照する

この時に
変数 blReference, blDeletingを使って

Aの処理中 delete部分
while( blReference ){ Sleep(1); }
blDeleting= true;
delete p;
p = NULL;
blDeleting = false;

Bの処理中 参照部分
while( blDeleting ){ Sleep(1); }
blReference = true;
char* cp = (char*)p:
//以下参照
blReference = false;

っていうのは安全でしょうか？

>>57
先ず基本的にblReference, blDeletingとも、きちんと扱えるようにしないとダメ。
要は、OSの用意しているクリティカルセクションなどの機構を使う必要がある。
つーか、マルチスレッドプログラミングの基本なんだが、大丈夫なんか?
それと、cpにNULLが代入されること自体は問題ないの?

weak_ptr使えハゲと言うしかないレベル

weak_ptrってboost?
マルチスレッドを考慮されていたの?

>>58
volatileしておけば、
まあいいんじゃない

sleep で待つのは効率はよくなさそうだけど

volatile使ったとしてもコンパイラによっては安全だとは言えないんだよ

安全って、思いたい理由の方に興味があるんだけど

むしろ安全だといえるコンパイラを知りたい

volatile使っても結果変わらない事の方が多い気がする

そりゃそうだ

安全だと思うと、コンピュータがそれを理解して動いてくれると思いたいのかな

volatileしてダメだったケースに遭遇したことないなあ。

まあboolでの同期・排他は簡単なケースにしか使ってなくて、
まじめなのはcritical sectionとかmutexで排他・同期するから
気がついてないだけかもしれないけど。

>>57
>// スレッドA
>while( blReference ){ Sleep(1); } // 1
>blDeleting= true; // 3

>// スレッドB
>while( blDeleting ){ Sleep(1); } // 2
>blReference = true; // 4

スレッドの処理が時間的に番号の順で行われる場合がある。
つまり、この処理はスレッド間の排他にはなっていない。
おとなしくクリティカルセクションを使ってロックした方がいい。

>>69
InterlockedExchangePointerは？

も一個、volatile bool a, b; があるとして、
　a = c;
　b = d;
の代入順序は、a, bがたとえatomicな型でvolatileだからといって
プロセッサのアウトオブオーダー実行のレベルでは実施される順序が保たれる保証はない、
よって、上記代入を行ったコア以外のコアからaやbを代入順序依存で参照する場合は
メモリバリアが　必　須　、
という理解で合っていますか

>>71
http://msdn.microsoft.com/en-us/library/ms686355%28VS.85%29.aspx
> The following synchronization functions use the appropriate barriers to ensure memory ordering:
> ・Functions that enter or leave critical sections
> ・Functions that signal synchronization objects
> ・Wait functions
> ・Interlocked functions

>>72
はい

>>64
javacやcscじゃね

メモリバリアってのはgcc特有の表現で
atomicな処理とは関係ないんだけど

>>73
�dクス
SetEvent()は2番目（・Functions that signal synchronization objects）、
WaitForSingleObject()は3番目（・Wait functions）ってことでおkそうですね

>>75
メモリバリアはアウトオブオーダー実行するアーキテクチャに共通する概念であってGCC固有というわけではないですにょ
とかいろいろあるが説明がﾏﾝﾄﾞｸｾ、

ただの最適化抑止のおまじないみたいなもんだよ

>>77
ちょっそれvolatileの方ｗｗｗｗｗ

まあ>73の通り、Windows API内部でよろしくやってくれるので普通はメモリバリアの方は意識しなくて良いっぽい
おそらくUNIXのシステムコールも同様でよろしくやってくれるから知る人ぞ知る知識になってしまうのだろう…

マルチコア時代の並列プログラミング
〜ロックとメモリオーダリング〜
http://www.nminoru.jp/~nminoru/data/b2con2006_nminoru.pdf

gccのvolatileってのは、ちょっと特殊なんだよ

>>77,78
真相はもっと複雑怪奇だったりする
http://yamasa.hatenablog.jp/entries/2009/07/20
http://msdn.microsoft.com/ja-jp/library/bb310595%28VS.85%29.aspx

つまり、VC++2005以降である限り、volatileを使うとメモリバリアも面倒をみてくれるらしい…

ここらへんの話は
　・（インラインでない）関数呼び出しの副作用を恐れてコンパイラが最適化を自粛
　・volatileによって明示的に最適化が抑制
　・システムコール内でメモリバリアの面倒をみてくれる
　・ハードウェアがコア間でキャッシュのコヒーレンスをとってくれる
といった事情が絡み合った結果、運よく問題を生じないケースも多々あるので
コードをバリバリ書いているような人でもきちんと理解していないことがある（あった）

アトミック変数とか作って、ド素人に誤解釈されたらどうすんだろ、この人

>>81
> つまり、VC++2005以降である限り、volatileを使うとメモリバリアも面倒をみてくれるらしい…
そこで面倒を見てくれるのは「release/aquireメモリバリアとしてのみ」であることに注意。
http://yamasa.hatenablog.jp/entry/20090816/1250446250
こっちのSequential consistencyの性質は、VC++2005以降のvolatileでも持っていない。

>>83
ドシロウトがなんでスレッド使った開発に加わるんだよ

なんで排他の話ばっか出てくるんだ。
スレッド間で書き換えしまくるような変数なんて殆ど無いだろ。

それはともかく、C++向けのクロスプラとフォームなスレッドキューって無いものか。

>>86
>なんで排他の話ばっか出てくるんだ。

マルチスレッドで問題になるところと言うか、排他を最近覚えた奴が
使いたくてしょうがないんだろ。

>>86
スレッドの実装が違うだろう、LinuxとUNIXなら同じだが

>>85
じゃあ、うわっつらの言葉だけ知ってる甘ちゃん系ではどう？

>>88
boostとか抽象化レイヤー用意すればできるだろ。

しかし、仕様の安定したスレッドキューがない。
もう、自作スレッドキューを保守するのは嫌だお

>>90
皮かぶせりゃいいだろうけど、

そこまでして、

そこまでしても

おまえら何回C++におけるatomicとvolatileの話を繰り返せば気がすむの

それしかネタがないからさ

>>92
スレッドキューの話しだせ

だって手法なんて先駆者が出し尽くしただろ

スレッドキューって何だ？
スレッドセーフなキューってことか？
それともGCDみたいなタスクキューのことか？

タスクキューのことだよ。
てかスレッドセーフなキューってなんだよ。それだったら
別にキューに限定せずスレッドセーフなコンテナの話でいいだろ。

java.util.concurrent.BlockingQueueのことだろ

同期処理を間違いなく設計するための、何か良い手法やツールはないですかね？

ペーペーのビギナーだというのもあるのですが、
複数のmutexを混在させなければいけない時にぼんやり書いたコードでデッドロックを発生させたり、
waitに到達していないのにシグナル発射する可能性のあるコードを書いてしまって、
そのデバッグで無駄に体力を消耗しています

馬鹿には無理

>>99
排他処理、スレッドモデルと実装を勉強すれば

ビギナーには無理と思うが

>>99
もうそこは、共有している資源と mutex の一覧表作って、地道に設計してレビューで
確認するしかない。

imagix とか確認を支援するツールはあるけど。

>>101
やんないと、他に仕事ないんで・・・・

>>102
かなり頭がよくないと、サラリと正しいコード書けないですよね（棋士的な意味の頭のよさ）
そうか、地道にやるしかないのか(´・ω・｀)

・・・売り物なんですねimagix
自分の担当業務以外にも使えそうなので、ちょっとチーム内に紹介してみます




とりあえず、今の自分のレベルでミスりやすいところを正しく実装するための比喩をいくつか考案中です
↓
例１
スレッド間同期は、キャッチボール
ボールを受け取る側は、しゃがんでいないとボールをキャッチできない

例２
スレッド再開時の手順は、競馬のスタートと同じ
�@ゲートを閉じる（送信側mutexロック）
�A馬がゲート前に並ぶ（受信側wait）
�Bファンファーレが鳴る（signal）
�Cゲートが開く（送信側mutex開放）

mutexなんか使わずfuture、promisで凌げ

>>103
転職したほうがよくね
ハロワ通いでもしてみたら

まず10年間C++を勉強しろ

>>106
Ｃ＋＋関係ないやん

>>103
比喩を作ることができるならすでに理解できてるんじゃないの？ってことで、
結局比喩は不要だよねって流れにならないのかな。

結局無理てことか、初心者というより基本が

>>103
とにかくソースコードをきれいに書け
そうすれば、ソースコードが間違いを教えてくれる

>>110
> そうすれば、ソースコードが間違いを教えてくれる

おっ、なんか響きがいい言葉だな。

Joel on softwareの和訳ページ『間違ったコードは間違って見えるようにする』
を紹介しようと思ったが今ちょっと繋がらないようなので原文で読んでちょ↓↓↓
http://www.joelonsoftware.com/articles/Wrong.html

教えてください

g++でコンパイルしたプログラムのプロファイリング、特にスレッドの動作の
効率を見たいのですが、Linux環境で使える定番のフリーツールはないでしょうか？

gdb

ﾏ
ｼﾞ　 ﾊ ,,ﾊ
ﾃﾞ　(；ﾟ◇ﾟ)z
!?

プロファイラでわかるのはどの部分が処理時間の何%を使ってるか
ぐらいであって、スレッドの動作効率なんていう個人の価値観みたい
なものは測定できんだろ。

あります

>>118
どういった理由でしょうか?

http://www.albahari.com/threading/part4.aspx
>The following implicitly generate full fences:
>Setting and waiting on a signaling construct

という記述を見つけたのですが、これによれば
valへの書き込みをinit.Set()より後に、valからの読み込みをinit.Wait()より前に
という事は行われないように思えるのですが。

判ってるのに質問するなボケが

それを否定されたから理由を聞いてるんじゃないのか

C#が自ら自身の仕様を質問すること自体が。
まぁ、人間だって自身についてどれだけ知っているか怪しいもんだが。

>>96
の発言で思い出した。
GCDといえば、最近WindowsとLinuxにも移植されたっぽいんだよね。
http://opensource.mlba-team.de/xdispatch/docs/current/index.html

pThreadとかWin32スレッドをローレベルで使うよりお手軽な気がする。
ちょっと試してみるわ。

123だけど、
XDispatchだが、Windowsであっけなく使えた。
こりゃいいぜ。Win、Mac、Linuxで同一ソースでGrand Central Dispatchが使える。
マルチスレッドプログラミング新時代到来って感じだw

XDispatchの導入記事を書いてみた。
https://docs.google.com/document/pub?id=1miIRZh8QteYzjIiU7GjcGSshTp470qHbRQUh0wf12Sw

突っ込みどころあったらご指摘よろ。

libdispatch + α、って感じなのか

>>126
そうみたい。
基本的にはマルチプラットフォームでやりたい場合は${ ~ }の記法とautoを使えばオッケー。
他にも標準のlibdispathには無い機能とか、Qtユーザー向けのQtDispatchとかあるみたいだけど、そこまではまだ調べられてない。
時間があったらもっと調べてみて、追記してみるよ。

Win32でのプロセス間リソース共有の仕方で悩んでます

1. ポーリング＝Mutexで保護された共有リソースの変更を常に監視
2. サーバー(orクライアント)スレッドでEvent監視+Mutexで共有リソースを保護

余計なCPUリソースを食うのはどちらなんでしょうか？定性的な評価と理由を教えてください
（定性的な評価＝プロファイルで調べろは無しでお願いします）
自分は「重さ：Mutex>>>>Event>>>>>>>CriticalSection」というイメージがあるので、
2のマルチスレッドのコンテキストスイッチの重さを考慮しても1の方が重いのではないかと考えています

(ﾟДﾟ)ﾊｧ?
Mutexを奪い合えばいいだけだし。

Event vs. Pollingは宗教戦争

何もすることがなきゃ寝て待ってればいいだけ
何かしたけりゃイベント来るまでしてればよかろう

Mutexが重いんじゃなくてポーリングが重いんだろ
イベントやメッセージ等の非同期通知が使えるなら、そっちのほうが軽いのは当然

>>128
> Win32でのプロセス間リソース共有の仕方で悩んでます
winすれで聞いたら
> 余計なCPUリソースを食うのはどちらなんでしょうか？定性的な評価と理由を教えてください
人から聞いたことを信じるの？

効率を気にする香具師が2chで質問するとかもうね

>>135 それ RAW じゃね

シングルスレッドのメモリ命令は RAW (対象アドレスが被らない) と
WAW (命令による) の特定ケースを除いて命令順通り、
マルチスレッドの各スレッド間では、全パターンに入れ替えの可能性あり。

たぶん MSDN の記載は誤解を招くかと。
こちらの根拠は以下の Volume 3A, Chapter 8.2

Intel 64 and IA-32 Architectures Software Developer's Manuals
http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html

write -> 0x1000
...
read -> 0x2000

と明らかに異なる場所へのアクセスであり、... の間に他のメモリアクセスが
無ければ、read を write の前に持ってきても結果は変わらないはず。

>>135
WARはレジスタリネーミングと同じだよ。
上書きするなら依存関係が切れるので命令の実行順序は入れ替え可能になる。
結果を内部で保持しておいて後で書き出す。
そして実際のメモリの内容は命令の順序通りの結果になる（ならなかったら大変）。

でいいかと。

>>137の補足しとくと、同一プロセッサでも異なるアドレスだとリオーダ可能なので
順序が重要な場合はメモリフェンスが必要になる。
別のプロセッサ間でもリオーダ可能ということになる。

別のプロセッサとの同じメモリに対するアクセス順序はタイミング次第で複雑なので
必要に応じてロックプレフィックスを使う。

>>135
MSDNのほうが正しい。
昔はIntelのdeveloper manualの記述が曖昧だったこともあり、
間違った解説が結構ある。

>>136-138
マルチスレッドでもRAW以外は入れ替わらないよ。

>>139
キャッシュラインがコピーされた状態ではRARの順番は替わりうると思うけど
RAW自体は入れ替わらないんじゃないかな。
実際のWriteの前にReadが割り込む可能性があるけど、それはタイミング次第ってことで。

lockプリフィックス使うんじゃあ

>>139
そうか、マルチスレッドでもリオーダは無いな。他から割り込まれる可能性があるだけだ。

>>136-142さん、さんくすでした。
MDSNが正しかったのですか。

＞ それ RAW じゃね
でした。コードの順番と英語表記は逆になるんですよね。誤解してました・・・。

この辺を勉強する本とかないでしょうか？
「The Art of Multiprocessor Programming 並行プログラミングの原理から実践まで」
は読んでみたのですがロックレスアルゴリズムの原理だけでCPUごとの実装は
なかったのであまり役にたたなかったです。

ハードウェアを実装するとなったらそれこそ本一冊どころではすまないだろうけど、
データの同期に関しては何が危険でどうすれば安全に扱えるかが区別できればいいんじゃない？
だから本を買って読むほどでもないような。

CPU内の順序はOut of Orderが関係していて、CPUは可能な限り速く実行しようとするから
順番が入れ替わってしまうってことで、それをコントロールするのにメモリバリア命令がある。
アセンブラの最適化にも関係してるから、プロセッサの最適化マニュアルとかも参考になるかも。

マルチプロセッサではキャッシュコヒーレンシやMESIプロトコルとかの概略を知ってればいいんじゃないかな。
他のプロセッサに割り込まれて困る部分にはlockで保護するとか。

Java の資料だけど「コンパイラ開発者のためのJSR133クックブック」ってのはどう？

>>145
邦訳版はダメ。
肝心のアーキテクチャ毎の表などが古いままで間違っている。

RafterWってシングルスレッドなら絶対安全？
途中で実行cpuが変わってもosが面倒見てくれるから気にする必要はないってこと？
実行cpuが変わることあるかしらないけど

まぁ普通にコード書いてて入れ替わる訳ないから大丈夫か

>>147
> まぁ普通にコード書いてて入れ替わる訳ないから大丈夫か

普通に入れ替わるだろ。
切替前に読み込んだ情報は、違う CPU でもちゃんと復帰するから
問題ないはず。

>>148
書き方が悪かった。

マルチプロセッサの環境でシングルスレッドのコードを実行してて、
実行CPUが変わったとしても読み書き順が入れ替わらないでしょう？

そこはOSがプロセス切り替え時に勝手にバリアをかけてるはずだよね？ってこと

>>149
ああそういうことか、それは大丈夫だと思うよ。

バーリアー！平気だもーん！

MemoryBarrier()の実装ってx86では単なるxchgなのな。
なんでmfence使ってないのだろう？速度では大差ないってことなのかな。

MemoryBarrier macro (Windows)
http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208

↓はC++11のスレッドライブラリ作った作者の本らしいんだが、pdfで全部公開されてる。
ありがたいのでだけどメモリフェンスは std::memory_order_acquire みたいな一般命令で
隠すようなコードしか書いてない。

C++ Concurrency in Action: Practical Multithreading
http://www.amazon.co.jp/dp/1933988770/

マルチコアでないマルチプロセッサ構成で、
外部キャッシュや主記憶のシステムコントローラが、
ＣＰＵ本体より弱いメモリモデルを採用してる場合に意味を持ってくる。
Windowsではこうゆうハードウェア構成は想定してないはず。

>>153
違うよ。全然違うよ。
とりあえず、これでもじっくり読め。
msdn.microsoft.com/ja-jp/magazine/jj883956.aspx

ところでmfenceは何でSSE2の制御命令に分類されてるの？

>>152
MemoryBarrier()はx64でもsfence/mfence使ってないな。
やっぱり処理速度の関係だろうか。
まるでenter命令並みに使えない。

x86
0000b　87 04 24　xchg　DWORD PTR _Barrier$66624[esp+4], eax
x64
0003a　f0 83 0c 24 00 lock or DWORD PTR [rsp], 0

>>155
xFENCE命令はMOVNTPS, MOVNTPD,などのNon Temporal転送命令向けの機能で、
この系統の命令だけx86のメモリモデルに従わないので専用のFENCE命令が必要となった。
このうちLFENCEとMFENCEは普通のx86命令にも効果があるが、
パフォーマンスがxchgに劣る。

なんでxchgがバリアとして使えるの？

メモリに対するxchgは自動的にlockを伴う

確率的にいつ終わるかわからない時間の掛かる処理をマルチスレッドを使って複数同時に
実行させると、シングルスレッドよりも早い時間で終わる確率が高くなると思うが、これについて貴様らはどう思う？

ちなみにクロスワード自動作成ソフトを作ってますっ

辞書ひく時間が糞長いから、マルチスレッドやっても大して変わらない

>クロスワード自動作成ソフト

どこらへんを並列化できるのん？

バックトラック乱れ打ちじゃねーの

同じレスを各板に乱れ撃ちする作業だろ？

マルチスレッドにしたら５〜８時間に１回エラーが出るようになった。でもデバックできないよorz

つログ

同期もわかってないのにマルチスレッドにするからだ。

同期とったら並列の意味がなくなりそうでためらうときがあるな
待ち合わせキューにするくらいなら順番に処理した方がましな気がする

つスーパースカラー

粒度変えりゃいいじゃん

マルチスレッドって自作できるんですか？
以前nyの書籍を読んだときに、開発者の人がマルチスレッドを自作したと書いてたような気がするのですが
C言語でも自作できるんですか？

マルチスレッド・マルチタスクで動いているように見せることは出来る。

並列動作させたい複数の処理を細切れにしてちょっとづつ実行して
グルグル回す。

>>173
タイムシェアリングみたいにやるってことですか

>>174
俺が>>173で書いたのは、タイムシェアリングではなく
ノンプリエンプティブ・マルチタスク。
例えば無限ループ内に3処理 A, B, C があったとして
それらをマルチで実行したければ、それぞれを
A1, A2, A3
B1, B2, B3
C1, C2, C3
などと細切れに分割し、
A1, B1, C1, A2, B2, C2, A3, B3, C3,　A1, ……(無限ループ)
と実行する。

いまでも、組み込みでコントローラやセンサーを制御する小さなCPUは
マルチタスクの能力を持っていないのが当たり前のようにあり、
これでマルチ動作させるのに当たり前のように使われる手法。

スレち

スレチというほどじゃないんじゃない？

OSレベルでスレッドのサポートが無い場合は、
言語ランタイムレベルのグリーンスレッド
タイマー等の割り込みの利用
メッセージポンプのループ利用
NT Fiber

スレッドはないけどプロセスのマルチが出来るなら、
パイプなどでプロセス間通信の利用
といったところかな

俺もスレチじゃないと思う

windows 3.1 を思い出すな

ファイバーってレアすぎ

>>175
win31 のことね

気が早いな
まだ8だぞ

2000があるのに…

>>175をタイムシェアリングだと思ってたな。もう少し勉強しよう。

ファイアー少なくてレアすぎ

広義だと含むのとちゃうかな
おさ〜ん的にはTSS(TSO)のホスト端末を思い浮かべるけど

ファイバー使ってみたけど、
フェーズとswitchより
シンプルに書けたよ。

C/C++　で勉強したいのですが、おすすめの書籍などありますか？
もしくは一から学べるようなWebページがあれば教えてください

D の方が良いよ

猫でもわかる

>>188
D のほうが書きやすい？触れたことないのでわからんです
>>189
猫でもわかる は、Web版が俺にはちょっと分かりづらかった記憶が
書籍だとそうでもないのかな

C++のBoostを利用したThreadプログラミングの解説ページがあったので今はそれ見てます

>>190
触ってもいいお

>>191
どれどれ

>>191
ペロペロ

マルチスレッドって自力だとどうやって書くの？

pthread_create()

>>194
std::thread th{
　[]{std::this_thread::sleep_for(std::chrono::milliseconds(3000));}
};
std::printf("うんこ\n");
th.join();

例の金子がny作るときにマルチスレッドは自作したんじゃなかったっけ？

なんとかしてこれを読むと良い
http://ci.nii.ac.jp/naid/40000002652

>>197
あれ、シングルスレッドだよ。
Windows3.1みたいな方法で複数のタスク回してる。

小学生がBASICで弾の連射実装してるレベルだろ。

グリーンスレッドとは違うの？

グリーンスレッドなんて初耳。wikip見たらなんかトンデモな説明なんだが。
これは誰が言い出したんだ？　バズワードくさい。

レッドスレッド、ブルースレッドはあるのでしょうか？

OSが関与しないスレッドの実装のこと。ウィキペディアの記述がタコってるのはいつものこと。

基本的な理屈はそう難しくないけど、実際にはreadとかでどれかのスレッドがプロセスごと
ブロックされると、他に走りたいスレッドが居ても走れなくなっちゃうので、そのへんを
どう手当てするかがカギ（そういった所だけOSが支援するとか、ブロックする可能性がある
システムコールに関連するものは全てスレッドライブラリが面倒を見るとか）。

よく分らんな。スレッドってそもそもOSが定義したものだろう。
アプリ側がたかが永続性のあるサブルーチン程度のものを
勝手にグリーンススレッドって呼んでるだけじゃないのか？

まさしく小学生がBASICで弾の連射実装してるレベルの話。ガッカリ度120%。

ユーザースレッド、ユーザ空間でか、なるほど
カーネルスレッド、カーネル空間でか、なるほど
グリーンスレッド、仮想機械上でか、で、なんでグリーンやねん。それこそ>>203

http://dl.acm.org/citation.cfm?id=603551
↑これが「小学生がBASICで弾の連射実装してるレベルの話」に見えるのか。
さぞかしスーパープログラマ(笑)様なんだろうな。

その例え話しとその提示したのと繋がりそしてなんでその皮肉になるのか、200文字以内で説明しなさい

wikipediaのスレッドの項目の所まで加筆してやがるww
バズワード確定だな。エミュレータでゲーム動かしたらグリーンスレッドかよw

そんなのスレッドと何の関係もないのにスレッド言うなや。

結局、逆の意味でのウィキペディア馬鹿か。
一人で言ってろw

グリーンCPU。
グリーンプロセス。
グリーンヒープメモリ。
グリーンスタックメモリ。
グリーン仮想メモリ。
グリーン物理メモリ。
グリーンマルチタスク。
グリーンネットワーク。
グリーンアップル。

おれもいっぱい考えました。

グリーンPC
グリーンディスプレイ

が抜けている

ソイレント

MZ-80Kの話をしてるのかと思ったぜ

>>214
そりゃMZ80Cだ！
MZ80Kはモノクロだ!

> ユーザースレッド、ユーザ空間でか、なるほど
> カーネルスレッド、カーネル空間でか、なるほど
> グリーンスレッド、仮想機械上でか、で、なんでグリーンやねん

ユーザースレッドとカーネルスレッドという言葉はそれぞれ、
M:Nスレッドモデルとかの議論で、カーネル空間のコードの実行におけるスレッドと、
ユーザー空間のコードの実行におけるスレッド、という意味で使われる。

グリーンスレッドというのは、スレッドAPIを（可能な限り）ユーザースレッド内で実装した
スレッドAPIの実装を指す。

以上のことが何も理解できないバカには、なにもかもがバズワードに見える。

バカですがなにか？

命名の由来のことなのに、Wikipediaから意訳したようなのを偉そうにのたまう、他人を馬鹿呼ばわりする自称天才様w
天才過ぎてどれもこれも バズワード 扱いしていると思い込んでいるようだしなあ。御愁傷様でw

> バズワード確定だな。エミュレータでゲーム動かしたらグリーンスレッドかよw
>
> そんなのスレッドと何の関係もないのにスレッド言うなや。

この威勢はどこ行ったのかなぁw

>グリーンスレッドというのは、スレッドAPIを（可能な限り）ユーザースレッド内で実装した
>スレッドAPIの実装を指す。

ハナからスレッドの定義に当てはまらないのにスレッド言われもなぁ。

WEB2.0と変わらんレベルの造語。
どうせまたジョブスオタクの低脳営業SEが言い出したんだろう。

スレッドの定義ってなんだ？

コイツの脳内ではシステムコールで実装されたものだけがスレッド、という定義なんだろう。
聞くだけ無駄だよ。

>>221
OSが管理する最小の実行スタック。

>>222
ではキミのスレッドの定義は？

222じゃないけど、スレッドっていうのはプログラムを実行する最小単位のことでいいんじゃないかな
OSが管理しているかどうかは問わない

スレッドっていう概念が実装されてるプログラミング言語が多いと思うんだけど、
この場合のスレッドはOS上の実装とは切り離されてるんだよね
例えばJavaのThreadクラスとか

OSが管理するものだけをスレッドと定義するとしたら、上記のようなプログラミング言語で
抽象的に実装されてるスレッドはスレッドとは呼ぶべきじゃないということかな？

実行スタックってなんだ、って思ったらウィキペディア（英語版含む）でそんな表現を使ってるのか。

一応GNU AWKと、.NETかCOMに、execution stackという用語はあるようだが。

>>225
そんなトンデモ言われてるも議論する気にもならん。
じゃあ、関数もスレッドなんですね。

もうアホかと。しかもJavaの〜とかふざけてるとしか。

ワロタｗ

中途半端に脳内完結してるんだろな

グリーンスレッド言ってた >>222　が定義を言わず逃げちゃった。

グリーンラナウェイ。

ファイバー、タスク、ユーザーレベルスレッドと呼ばれ方はあるが
スクリプト言語のスレッドやゲームのタスクシステムの実装などに使われているありふれたテクニックだろ
OSの実装も同じだよ、ただカーネルレベルでやってるからCPUの特権命令が使えたりするってだけ
もしやOSを書いたことも言語処理系を書いたこともないのか？

意味負

>>227
JavaのThreadクラスの何処がふざけてるんだ？

>>231
さっさとおまえの定義を言えよ、低脳。

もはや人格攻撃しかできないモードに縮退したか。

POSIXのスレッドAPIを実装したものがスレッド、という定義でいいだろ。

トンデモグリーンスレッド連呼してたのにそのスレッドの定義聞いたら答えないで
逃げ回ってるんだからもはや人格の問題でしかない。

クズである。

おまえが自分の定義と違うものに聞く耳を持たないクズってだけじゃないか。

自分がクズだろ。

>>237
自己紹介乙、でどうでしょう

>>238
その定義ってどれ？w　いいかげにんしろよ、クズ。

いい加減スレチ

グリーンスレッドはどう考えてもスレッドじゃないからな。
スレチ。

コンテキストの切り替えが出来るならスレッドの範疇でいいとちゃうの
LWTやFiberも範囲でいいだろ

Java屋は馬鹿だからな。なに言っても無駄。

馬鹿でわるかったなー

キチガイに触るな
居座っちゃうだろ

マルチスレッドとタイムシェアリングは違うの？

>>247
まずプロセスとスレッドの違いを理解してから

まずグリーンプロセスとグリーンスレッドの違いを説明してほしい。

グリーンスライムよりは手強そうなイメージ

グリーンプロセス()

このスレはカーネルレベルでの実装オンリーのスレになりました、ってことでFAね。
あるいは「カーネル型」のw

まだいるのかグリーンスレッド君

まだいるのかカーネル至上主義者君

v-sync割り込みでマルチタスクだお〜
DOS至上主義者が通りますよ〜

[要出典]

>>255
マウス用割り込みの方が良い。

マウスの付いてるパソコンはカッコ悪い

わーるかったな

マルチスレッドって使えるところが限られてる

これからマルチスレッドの勉強をしようと思うんだけど、
参考になるサイトとかコードとかを教えて欲しい。

特にワーカスレッドを複数立て、たくさんのデータブロックを順に渡して処理させるようなサンプルとか。
ネットを検索しても、スレッドが延々と動きつづけるか、処理が終われば使い捨てるものばかりで、
処理の終わったワーカスレッドに次のデータを渡して連続して処理させるものが見つからない。
また、可変長の演算結果を親スレッドに返す方法についても、どうすればいいのやら。
１個の結果データは固定長だけど出てくる個数が可変なので、固定長の電文を複数投げるようなイメージでも可。

動作環境はWin7-x64で、VC++を使いマルチコアCPUのコア数分ワーカスレッドを立てようと思う。
うちのは６コアなので、単純計算で６倍弱には高速化できると思う。

処理内容の原理試作としてシングルスレッドのDOSアプリとして組んで、鍵値に５を与えて動かしてみた結果、
データブロック数は３２０万個余り、データブロック１個あたりの演算結果はゼロ〜100KBと幅があるw
そして総処理時間の見込みは60〜150時間（まだ終わってない）。
鍵値を６にするとブロック数も処理時間も莫大に跳ね上がるから、
たぶん１台のPC内で完結させようとしても終わらない。

使い捨てと使い回しで、クロックにして1k~2kくらいの差が有るかどうかだから、使い捨てでＯＫ。

HotspotVMは？
と無茶振りしてみる

VCならOpenCLかC++AMP使えば良いんじゃね
CPUとGPUで切り替えも出来るし
CPUだけならPPLでも

VS2013か2012で、C++11のstd::threadとblockingできるqueueとstd::futureあたりを使えばいいんじゃないかな。

>262-265
ﾄﾝ

スレッドの使いまわしについて、ちょっと説明が言葉足らずだったかな。
やりたいのは最初にｎ個を起動するのまでは同じなんだけど、
データブロックを１個処理し終わったら次のデータブロックを処理させることで
全てのデータブロックを処理し終わるまでｎ個を実行している状態を維持したい。
（実際にスレッドをループさせるか破棄／生成を繰り返すかは重要ではない。）
ググって見つけたサンプルは、ｎ個のスレッドを最初に起動して、
ｎ個全てが終わるのを待って次の処理（結果表示とか）に進むような使い方のばっかりで、
起動したうちの１個でも終わったら次の処理をやってまた１個終わるのを待つ、みたいなのが見つからない。


開発環境については、実は結構古いのしか持ってない……
ので、これからVS2013の評価版をDLして試してみようと思う。

現状のx86コード、シングルスレッドでどうやら鍵値５の処理を70時間以内で終われそうな予感。
処理結果のファイルを分割し過ぎて恐ろしい数のファイルを生成しちゃってるので、
マルチスレッド化の際にはもっと纏めてしまわないとなぁ。
鍵値６は複数台のPCへの分散処理とかGPU処理とかを真面目に考えないと無理そうだけど。

そこまで仕様が決まってるならさっさと書けよって話だが。

自慢

なんの？ｗ

典型的なコード書けない君だったか。

>>261
OpenMPのparallel forで分割するだけでおｋ

>>271
もしも、それで済む用件だったら、一番楽だね。
VS2012と2013なら、無料版でもOpenMP使えるし。
手元のコードでOpenMPでforループ2048周をi7-3760Xで6倍速度くらい。
CUDAで780Tiで2048*2048cudaスレッドでさらに18倍くらいだった。

266の処理は、OpenMPのparallel for schedule (dynamic)でできる

ここはおまえの日記じゃねーぞ。

スレッドの数って
CPUのコア数より多くしても意味ないよね？

>>275
スレッド内の処理でI/O待ちとかしてる場合は意味あるんじゃないの？

ひたすら計算し続けるなら意味はない。
計算メインというだけならコア数の倍ぐらいまでは
スループットが上がることはある。

書きたいアルゴリズムを自然に書けるという理由で
マルチスレッドに意味があることはある
GUIなんかそうだろうね

そんなGUIの実装は見たこと無いです。

GUI スレッドと別に好きなスレッドを立ててうまくやっていけるってことだろうに‥‥
win16 の泣きそうな世界を知らないのか？

それはCUIでも同じだろう。

処理内容・数によるけど大量のパラ処理はCPUのマルチコアやNvidiaのGPGPUからAMDのGPGPUでopenCLが定番になってきたからな
そして、今後はAMDのHSAも定番になるって感じになっているし。

いつGPGPUが定番になってきたんだ。
むしろまじ使えないってスルーされてる感が半端ない。

それは nvidia/cuda

インテルのやたらコア数が多い奴にビットコイン掘らせたらよさげよね

GPGPUは特定の局面に限って言えば使えるんだが、一般の用途では
その特定の局面が存在しないというかわいそうな技術。

ちなみにbit coinのマイナーはGPGPUから専用設計のASICに
主戦場が移った。消費電力が段違いなんだとさ。
GPUでやったら電気代で赤字になりそうだ。

>>287
特定用途のみならICにしたほうが良いだろうな。

確かbitcoinでよく使われていたVGAはAMDだったはず。
ゲーム用VGAのGPGPU性能はいまはAMDのほうが良いのかな

FPGA経由でASICな。

しかも最近じゃあ、専用マシン（アクセラレータ？）を手に入れても、掘るより転売するほうが儲かるとかw

で、自販機の下に落ちてる100円玉を地道に拾うぐらいなら
ショベルカーでATMごと盗んじゃえってのがマウントゴックス。

>>290
ﾜﾗﾀ、でもまさにソレ
MtGoxってMTGのカード売りだったと知った時の苦笑いときたら

2年ほど前にbitcoin採掘をしていたが
お前らの想像の千倍くらい時間のかかる処理だったし
今もっと難しくなってるから既に個人で掘るのは無理なんじゃね

で、結局どのくらい掘れた？

千倍台で分散する

>bitcoin採掘
どういうこと？

>>295
むちゃくちゃ簡単に言うとBitCoinの正規のビットパターンは計算で求まる、でこれの正しい組み合わせを計算する事を採掘(マイニング)って言うだけの話

>>296
ありがとん

ちょいと相談。

データ処理とファイルI/Oを別スレッドに分けてstackを介してやり取りしてるんだけど、
気がつくとやたらメモリを食ってることがある。
調子のいいときは数ＭＢしか食わないのに、最悪は2GB食って落ちることもある。

ファイルの生成の様子なんかを観察してる限りで、２つの原因を想像。
A）処理済みデータをstackに積むのに比べてファイルに書き出す処理が追いついていない
B）stackがバカスカとメモリを確保している

ファイル書き出しのスレッドの内部処理は、共用stackからローカルstackにコピーして、
コピーが終わった時点で共用stack占有状態を開放、ローカルstackを順次書き出すようにしている。

Aは大量にデータを溜めることの無いようにファイル書き出しの頻度を上げる方法について、
Bはメモリを無駄に食わない方法について、アドバイスを聞きたい。

stackを使ったのはqueueに比べて頭が固定な分だけメモリの利用効率が高そうだったことと、
データの順番には意味がないから逆順になっても問題がないことによるものなので、
別のコンテナを使ったほうがいいなら、それでも構わない。

>>298
そもそも一旦メモリに載せる必要があるのか？非同期IOじゃだめ？
どうしても載せなきゃいけないとして、Aはあまり意味がない。
よほど頭の悪い実装をしてなければ、現状メモリを喰ってるってことは
inputよりoutputの方が遅いってことだ。頻度で解決する問題じゃない。
Bの方は、conditon variableでスタックのサイズが一定より大きくなったら
inputを待たす方法が一番簡単じゃないか。

＞調子のいいときは数ＭＢしか食わないのに、最悪は2GB食って落ちることもある。
常識的に考えてバグ持ち。

＞コピーが終わった時点で共用stack占有状態を開放、
ふつーstack<void *>。

バッファに制限を設けて
書き込みが詰ったら待てばいいだけでは

リングバッファ、そして新しいバグ

リングバッファてメモリが一杯になったらファイルに書き出すように実装するのが普通？

普通じゃない

どうすんの？あふれたら捨てるの？

環境によっては勝手にswapしてくれるかもしれない

>>305
ふつうは>>301の言うように空くまで書き込みを待たせるか捨てる。
待てないような要件ならサイズ固定のリングバッファじゃなく可変のキューを使うなりする。

書き出すデータのフォーマットを工夫してサイズを小さくするとか、
書き込み先をSSDにしたりとか、動作環境のスペックを見直すという手も。

>>307
ありがとう、バッファーの構造を別にして最大容量は設定しないといけないということですね

>>306
後出しになるけど、リアルタイムシステムのデータ収集のようなもの考えていたので

いるんだよなー、そもそも不可能なことを引き受けちゃう奴って

てへ、昔の話がねた

金あるならFusion-ioを使えばいい
圧縮で減るようなデータならsnappyで圧縮する

普通のリアルタイムではありえん

訂正　以上です

リアルタイムシステムというのがRTOSを使っているという意味なら
送信側か他のタスクがwait入れてなくて書き込みタスクが動いていないとかってバグじゃないかな
>>313
時代は変わりCPUを使って圧縮したほうがIOが減って低レイテンシにできる

リアルタイムっていうのは入力があってから何ms以内に応答を
返せなければならないみたいなシステムのことでしょ。
コンピュータ制御の工作機械で応答が遅くて削りすぎましたとか
許されないから。

>261だけど、概ね期待通りの動作になってきた
速度面でも、現在使用中のPCでシングルスレッドだと70時間ほど掛かってたから、
マルチスレッド化で６コアに分散して細部の調整込みで10時間切れれば恩の字と思ってたのに、なんと４時間半を切れたw
最新のCPUを使えば２時間も夢じゃないかも

あとは演算処理orデータのやり取りのバグを潰せばほぼ完成
（結果の個数が少し足りない）

シングルスレッドのまま細部の調整とやらだけでどこまで行くのやら

どんだけ時間がかかってるのやら。

共有/排他ができるロックと条件変数があるとき、これらを使って
共有から排他にエスカレーションできるロックを構成することってできる？

ロックとか条件変数って排他するものだよね。共有できるロックって何？
RCUのこと？

ええと、いわゆるread-writeロックのこと。

マルチスレッドは馬鹿には無理
馬鹿は使ったほうがいいところでマルチスレッドを使わずに
使わないほうがいいところっ使ってややこしくしたりする

負荷分散とか難易度高なのにね

スレッディング・ビルディング・ブロックについて勉強し始めた所なんだけど、どうなの？
理解して使うと安全で早くなりそうだとは思ったが、メモリ処理の効率とかどうなるんかな？
とか思ってる所なんだけど・・・

安全にするには、ある程度やった人しか...

メモリ処理の効率って具体的にどういう点？
mallocとかのメモリ管理の効率？それともキャッシュヒット率のような意味？

オライリーのTBBの本買ったけど途中まで読んで放置してたｗ
ラムダ式を使えばoperator()使わなくていいなら改めて勉強しなおそうかな

>>325
コンカレントコンテナとかは並列にメモリ割り当てしたり、キャッシュラインの競合を考慮した
アロケータを持ってるみたいだから、自前でやるのと変わらないぐらいにはなってるんじゃない？
TBBの本も中古ならかなり安いから買ってみるといいよ

基礎的な質問で申し訳ないのですが
同じ変数に複数のスレッドがアクセスしてはいけないのはわかりますが
同じコードに複数のスレッドがアクセスするのはいいのでしょうか？
例えば何の変数にもアクセスしない関数を複数のスレッドが同時実行するのはいいのでしょうか？

ダメな理由でも探してるの？

>>330
今書いているプログラムで
C#の関数の中でシグナルを使っているのですが
他のスレッドからその関数を呼ぼうとするとエラーが起こるのです・・・
もしかしたら関数自体にシグナルをかけなければいけないのかなぁと思って

C#のシグナルってよーしらんけど
エラーが出るってことは、質問の内容と違うことやってるんじゃないの

同期オブジェクトを保持している変数を上書きしていそうな気がするんだが

いろいろ分かってないだけだろう

ライブラリがマルチスレッドに対応してないだけかと

/MT

C#ならエラーメッセージやスタックトレースが出てるだろ

>>329
同じ関数は実行するのは、スレッドが違えばコンテキストスイッチが起きて、レジスタとかスタックが入れ替わるから大丈夫
メンバ変数とstatic変数さえ使わなければ何個起動しても排他も何も考えなくてよいぞ

同じ変数に複数のスレッドがアクセスするならクリティカルセクションが楽だ

linuxですがスレッドで同じファイルに書き込む場合、競合することってありますかね？

勿論。

論外

>>339
もう win32 のクリティカルセクションとイベントオブジェクトでおなかいっぱい、というかこれだけでたいがいうまくいくのでは？

複数のスレッドがひとつのミューテックスのアンロックを待っていた場合、
つぎにどのスレッドがミューテックスを取得するかはランダムですか

はい
待っていなかった別のスレッドがちょうどいいところに来てミューテックスを取得していくこともあります

いいえ
待っていなかった別のスレッドがちょうどいいところに来てミューテックスを取得していくこともあります

スレッドとミューテックスだけ覚えたけど
なにを作ったらいいのかわからんたい

チャット作ることにしました

consumerとproducerみたいのがいいんじゃないのかなと思ったけど、
チャット作ることにしたのね
がんばってください

>>349
チャットで詰まったら気分変えてConsumer-Producerにも挑戦してみます
あざす

>>349
いや、ありがとうございます

Win8.1 Cygwin64bit g++のpthreadなんですが、マルチコアCPUなのに性能改善しません。
なにか特別なコンパイルオプションがあるとか
特別なライブラリをリンクしなければいけないとかあるのでしょうか。
-lpthreadはつけてます。

エスパー能力はありません

そこをなんとかスーパーエスパーでお願いします

誠意を見せてください

DISKへのアクセスって並列にしたって意味ないですか？

・・・
FileA読み込み(::ReadFile)　１０秒
FileB読み込み(::ReadFile)　２０秒
・・・

で３０秒以上掛かりますが、
之をスレッドを起こしても意味無い？

よくわかってないけどDISKの特性によるのかなぁとかいってみる。

どういった特性ならどうなるのですか？

読み込みながら処理をしてみたいにな状態でない限りスレッド分けてファイル読むと遅くなるよ(デバイスが別であればまた違うのだが)
純粋にバイナリデータとしてファイルをメモリに丸ごと読み込むのであればスレッド分ける意味ない(CPUとメモリの方がディスクよりも遙かに速い)

遅くなる理由はなんですか？

俺様の質問に答えろとさ

まともに答えるとまた暴れだすだろ

>>360
FileAとFileBが同一のディスクに存在するとして、FileAがFileBが以下の
内容である場合、論理的に近いデータ(青森県と岩手県)は論理的に遠いデータ
(宮城県と長崎県)よりも物理的にディスクの近い位置に存在する可能性が
高いので、02→03→…→07→40→41→…→46という順番で読み込むほうが
02→40→03→41→…07→46という順番で読み込むよりも速く完了する可能性が
あります。

[FileA]
02青森県
03岩手県
04宮城県
05秋田県
06山形県
07福島県

[FileB]
40福岡県
41佐賀県
42長崎県
43熊本県
44大分県
45宮崎県
46鹿児島県

いまどきのディスクはインターリーブなんか考慮しても意味無いぞ

>>364
インターリーブってCPUが遅い時代の話だろ？
セクタリードの後でCPUが処理している間に次に読むべきディスク上の物理セクタが通り過ぎてしまうからシーケンシャルなセクタ処理でなくインターリーブした順序付けのセクタ使うって奴

趣味プログラムでInterlockedCompareExchange
で値が交換できた時だけそのスレッドが処理を進められるような感じで
作りこんでいるんだけど、何かこれだと問題ある？
一般的にはクリティカルセクションを使った方がいい的な話を聞くんだけど
sizeof(CRITICAL_SECTION)がチョット大きすぎるので使うのをためらってしまう

>>366
レースする可能性があるくらいじゃね？
まあ、ほとんど問題ないと思うけど。

>>367
間違えた。
レースじゃなくてスタベーションだった。

マ

int iで++iにミューテックスが必要ってことはiを同時に２つのスレッドが足しても２増えるだけで必要ないと思うんですけど？１しか増えないってこともあるんですか？

ＣＰＵによってアトムが違うから必要ってことですねわかりました。

御茶ノ水の博士の設計

>>370
Aスレッド:iから1を読み込んで++して2を代入
Bスレッド:iから1を読み込んで++して2を代入
答えは1増える

レース状態のことやね

同じcondition_variableでブロックしているスレッドが複数ある場合に、
notify_oneをしたら、どのスレッドが起床するのだろうか。

サッカーブッシュ日本代表日程ぷあたん（しゅっちょうまいくろ教育長交代）春文執行40代売上差額シュガーチョコ

宇ドナルドアナリストパワーストーンコーチングとしまえん
サッカーブッシュ日本代表日程古本屋よしたけしゅっちょうちょこしゅがー
ディーラー税務署天才開発者死亡詰みヨミドクターマイクロサービス不足
サッカーブッシュ日本代表日程ぷあたんシフト光金さかい強制バイト人権侵害問題
春分資源執行ニューヨーク低原価ぼったステーキソルトレイク福岡横浜新橋奴隷課金パチシフト強制バイト問題新潟米センター生残
コスメ２４チャリティー隠れ40代生活保護プレイボーイバイトレードいたりあん接待問題
マスコミKARDローンケーオーサービス不足婚活パーティー寄付金執行原発ビジネス
FBIチャイニーズタイホテル売上事務所ガチャ決算ガチャキャンペーン（販売報道陣過激派組織向携帯最新情報提供終了
校長発言細心注意ノートン産廃エラー(著作権クレーム中国反応融資高額教育費)(中国捕鯨団体40代社員サッカーコメント
高額入学金ヤフウ新橋大学ヤフウ新橋理事長FX経費 おじや50代資産ガリバズフィード40代エリート

>>375
リファレンス読め

CAS命令でロックしている部分を
_xbegin _xend やら xxx_HLEAcquireで代用すればCAS命令分のWaitをチャラにできるかと思ったんだけど
結果微妙に遅くなっただけだった
使い方間違っているのかなTSX

マルチスレッドにおける変数の排他処理についてなんだけど、
排他制御していない状態で複数のスレッドが同じ変数に同時にアクセスすることそのものは問題ないよね？
読み取り最中に書き換えたり、書き換え最中に読み取った場合にデータが破壊されるというだけの話だよね？

例えば2byteの変数があって、スレッドAが1byte目を読み込んだ時点でスレッドBが2byte目を書き換え、
そこでスレッドAが2byte目を読み取った場合に、
データが上位1byteと下位1byteで別のデータを読み取ったことになっておかしくなるってことだよね？

ということは何らかのフラグで下位1bitのみを利用するような変数であれば、
上記のような状況は起きないから排他処理しなくても大丈夫って認識でOK？

馬鹿乙

>>379
>>マルチスレッドにおける変数の排他処理についてなんだけど、
>>排他制御していない状態で複数のスレッドが同じ変数に同時にアクセスすることそのものは問題ないよね？

変数というだけでは分からない。
構造体とかC++の変数とかはそちらから見ても明らかに問題のはず。

>>ということは何らかのフラグで下位1bitのみを利用するような変数であれば、
>>上記のような状況は起きないから排他処理しなくても大丈夫って認識でOK？

1bit（あるいは1バイト、1ワード)がアトミックにアクセスできる
ことはシステムによって保証されていることが多い。

だから、その1bitの読み書きは出来る。
しかし大丈夫とか問題ないかということは、何を問題とするかを
書かないと答えようがない。

1bitはこれ以上分割できないので1ビットの半分だけ違う値になる、
ということはありえない。そういう心配をしてるなら大丈夫

ありがとう！
大丈夫かどうかというのは、
排他制御が行われていない変数へのアクセスそのものが原因となってソフトウェアがクラッシュしたり、
OSやハードウェアレベルの問題は起きたりしないよね？って意味

C言語で下位1bitしか使わない排他処理が行われてない変数があり、その1bitをif文で判定して処理を2通りに分ける場合、
必ずその2通りのどちらかになることは保証されるよね？
できるだけ高速化したいから、できるだけ排他処理はしたくない。

やっぱりアホか

>>382
馬鹿が書くと機械的に壊れることもあります
ソレノイドが焼損とか日常茶飯事

>>384
どのパーツのソレノイド？
説明してくれ。
パソコンは自作やら修理やらよく頼まれ続けてきてるから専門的な話OKだ。

すいません質問します。
Matlobで、
例えば５０００×５０００の行列をAとして
その１０×１０の区分行列をBとします。
Aの対角線上にあるBだけを取り出して他が０行列の行列を作るにはどうすればいいですか？
また、各Bの対角要素だけ取り出すにはどうすればいいですか？

・とりあえず全てのパラメータから0を１つずつ取り除く
・Aは500×500の行列
・Bはたった1つの要素で、インデックスは i = j
　それが500個ある
・つまり、「i==jであれば取り出す」それ以外は0にする。
・では、それを10倍したら？「 i ÷ 10 == j ÷ 10 」であれば、
　取り出す（但し余りは全て切り捨てる）それ以外は全て 0
・但し i jの上限はインデックスが0からとして、4999までとする。
・俺はMatlabは使ったことが無いので具体的な実装は知らない。

・その次
・i と jの上限は 4999
・対角の部分行列は簡単、「i == jならば」取り出す。
・その右は、「i == j + 10 」も該当
・同様に、「i == j + 20, 30 ... 10*n ... 10*499」も該当
・同様に、「 i + 10 == 」も該当
・「i + 20, 30 ... 10*n ... 10*499 == j 」も該当
・「該当しなかったもの」はその都度0を代入する

アホ

>>387
ありがとうございます。やってみます。

>>381
ウソ乙

【ＯＳ】OSX 10.8.5、Core i5
【言語】 C, C++
【実行環境】 XCode5.1, pthread

pthread を使って for ループを分割して実行するプログラムを書いたのですが、直列処理の方が速いです。
tbbやOpenMP でもやってみたのですが、直列の方が速いです。

上記の環境ではマルチスレッドで効率化を図るには、何か設定が必要なのでしょうか。
ざっくりした質問ですがヒントになるようなことでも教えて下さい。

マカーか

>>391
プログラムを見ないと分からない。
マカーじゃないから見ても分からないかもしれないけど。

大前提として、マルチスレッド化して速くなるようなジョブなんだよね？
スレッドを作るのもjoinするのもスイッチするのも時間が掛かるので、
それらがペイしないと意味がない。

ちゃんと作っていて遅いのなら、キャッシュの競合の可能性があるかも

tbbのくっそ初心者です。
下記のコードを試したのですが、直列実行した方が速かったです。
これってそもそも並列化しても速くならない類の処理なのでしょうか？

int main( int argc, const char * argv[] ) {
tbb::task_scheduler_init init( 4 ); //　物理２スレ、論理4スレ core i5
PrimeCounter counter;
tbb::parallel_reduce( tbb::blocked_range< int >( 0, count__, count__ / 4 ), counter, tbb::simple_partitioner() );
}

他所のヘッダにて、

bool isPrime( int n ) { // この処理がアホみたいなのはわざとです
if ( n < 2 ) return false;
if ( n == 2 ) return true;
for ( int j = 3; j < n; ++j ) { if ( n % j == 0 ) { return false; } }
return true;
}

class PrimeCounter {
public:
int count;
PrimeCounter() : count( 0 ) {}
PrimeCounter( const PrimeCounter& instance, tbb::split ) : count( 0 ) {}
void operator() ( const tbb::blocked_range< int >& range ) {
for ( int i = range.begin(), end = range.end(); i < end; ++I ) {
if ( isPrime( i ) ) { ++count; } }
}
void join( const PrimeCounter& pc ) { count += pc.count; }
};

書き忘れ >>391 のマカーです。

度々すみません、タイポありました。（多分本筋と関係ないですが）
関数 bool isPrime( int n ) のループ。
　誤　for ( int j = 3; j < n; ++j )
　正　for ( int j = 2; j < n; ++j )

RelativisticProgrammingを日本語で解説してるとこ、ないかな？

++j

#include <stddef.h>
offsetof(type, member-designator);

僕の知り合いの知り合いができたパソコン一台でお金持ちになれるやり方
役に立つかもしれません
グーグルで検索するといいかも『ネットで稼ぐ方法　モニアレフヌノ』

4DXJZ

Z1B

>>394
超亀レスだしﾃｷﾄｰだけど、counterがシングルトンなら
countのインクリメントでシリアライズされるんじゃね？

Intelのハイパースレッドでスケールするか否かのアルゴやデータ構造のパターンとか、評価基準をまとめた本なりサイトなり御存じでしたら教えてください。

400MBのデータを一括でコピーする処理を並列化してもノイマンボトルネックに掛かってスケールしないと思うんですが、boolの配列(newしたもの)でやるとある程度スケールします。
何でですか？

>>404
bool の配列が、例えば、8個の bool 値をまとめて 1バイトとして格納している場合で、
for ( i =0; i < 100000; i++ ) {
dst[i] = src[i];
}
のように書いて、かつ、コンパイラがこのループを「そこまでの」最適化はしなかった場合、
32BIT 環境の場合なら、32回のループで 1 DWORD 分の実メモリやキャッシュ・メモリへの
転送が生じるだけになるかも知れない。その他のメモリアクセスは、基本、code の
fetch だけになり、全てCPU内部のキャッシュ・メモリに乗ってしまう。

だから、マルチスレッドでこのループを分割して行えば、32スレッドまでなら、
高速化が起きる気がする。

そういう問題でなくて？

>>404
あ、あと
>400MBのデータを一括でコピーする処理を並列化してもノイマンボトルネックに
>掛かってスケールしないと思う

これだけど、以外に高速化されたりするかもしれない。
実際の CPUはそんなに賢くないので。

色々複雑。

チップセットや DDR DRAM、バス・アービタなどの事はそんなに詳しくは無いけど、
「ブロック転送命令」みたいなのがあるかも知れない。そして、
CPU で、rep movsd などが実行されるとき、CPU は、自分で転送せずに
チップセットと連携してバス・アービタにその命令を発行し、すぐに次の命令
から実行を再開したりするかも知れない。昔で言う「バスマスタ転送」や「DMA転送」
に似たようなやり方。

なんでそう思うかというと、主記憶(外部メモリ)はCPUのクロック速度にはついていけない
はずなのに、以外に CPU のブロック転送が速い気がするから。

確認は取ってない。

返信ありがとう。
DMA転送できるものをコンパイラが探知できるか疑問に思ってました。CPU機能としてのブロック転送は関係ありそうですね。
ワード単位処理は確かにやってそうです。

マルチコアでスケールできる処理って割りと限られてますね(汗。

バイナリ見れば済む話だよね^^

>>408
[追加]

DMAでなくとも、CPU自身が命令実行の処理とは独立して主記憶の間で
転送をする仕組みは当然あるので、ブロック転送の予約みたいな事で、
実際の転送処理が終わってなくても次の命令に進んだりするようなことは
あるかも知れないと想像してみる。

無いかもしれないけど。

>>409
いや。例えば、バイナリだと、
rep movsd
の1命令がそこにあるだけで、命令表を見ればブロック転送をする命令とあって、
擬似命令レベルでの処理までは書かれているが、バス転送レベルでそれをCPUが
どう処理してるかまでは分からない。

double 1GＢをコピー元のデータを加工してからコピーする場合は、どうやってもスケールしないんですかね、この話の感じからして。
書き込みタイミングが結果論でずらせるので、並列化で多少は見込みアルのかな。ーー自分で実験した方が良いですね。

キャッシュにデータを書き込むけどメモリに書き込まない、とか
キャッシュのデータをメモリに書き込む動作をC++など言語で実装できないでしょうか。
勘でやる他ないのでしょうか。

>>414
自分で inline アセンブラか、単体のアセンブラを使えば出来る。
ただし、VC++ の inline アセンブラを使う場合は、結局、どんなコード
になるか分からない部分があるので、アセンブリ・ソース出力オプションか、
または、IDE の逆アセンブラでコードを確認する必要があると思うが。

ただ、個人的には、それ以上に、IA32のキャッシュ制御命令は、大量の
文書を読んで理解するのが大変に思うけれど。

>>414
intelの大体i5以上の新しい石だと
_xbegin _xend 等の1次キャッシュから下位のメモリへの
ストアタイミングをコントロールできるTSX命令群がそれっぽいかと思う

確か、もっと古いCPUでも、
mfence や、movxxxxx 系の命令でも色々出来たと思う。

物凄い複雑なので、ちゃんと理解してないけど。

以下のようなものも関係している。複雑すぎて理解してない。

https://xem.github.io/minix86/manual/intel-x86-and-64-manual-vol3/o_fe12b1e2a880e0ce-429.html

・WBINVD, PREFETCHh, CLFLUSH, CLFLUSHOPT,
・非一時的な移動命令(MOVNTI, MOVNTQ, MOVNTDQ, MOVNTPS,
　MOVNTPD, INVD)
・第3レベルのキャッシュ無効化フラグ（IA32_MISC_ENABLE MSRのビット6)

質問：
ある資源を生成破棄するメーカースレッドがひとつと、その資源を使うユーザースレッドが複数ある。
メーカースレッドとユーザースレッドは排他的に資源にアクセスするが、ユーザースレッド同士は排他的でない。
どのように排他処理を実装すればよいか。

>>419
Producer-Consumerパターンか
間にChannel挟めばちゃんと動くよ

課題

2コア4スレッドってCPUだと
4スレッド同時に動くの？

動くよ
ただしハードウェアリソース的に余裕がある部分(SSEとか)位しかあまり効果がないな
マルチスレッドではやや分がある
というのはコンテキストスイッチの負荷が純粋に1/2になる
レジスタの内容をメモリに退避する回数が1/2になればそりゃ軽くなるよね
整数演算ではあまり期待しない方がいい

同時に動いてないなら排他制御しなくていいみたいな勘違いしてそうな質問だ。

そこまで深くは考えてなかったんだけど。
CPUコアひとつなのにどうやって2スレッド同時に動くのか不思議だったから。

実際に鯖用CPUではHT切ってあるもんな
かえってパフォーマンスが低下するとかで
最近の例の脆弱性との絡みもある
その代わり最初からコアいっぱい積んでいる

×切ってある
◯BIOSで自分で切っている

on/offをアプリ側で指定できないし、
性能が線形に上がらない時点でHTを考慮した設計は面倒すぎる。

マルチスレッド・デザインパターンの本にあった例だけど
ワーカースレッド(スレッドプール)を実装せよ
なお言語は自由とする

マルチスレッドの解説本はいくつもあるけど
マルチプロセッサのプログラミングって参考書ないのかね。

マルチスレッドの解説本でカバー出来ないくらいのマルチプロセッサのプログラミングだと
かなりマニアックというかプロセッサ固有の問題の割合が大きくなると思うので
そういう方面で探すしかないのではないか
それだけに特化した専門書は無いかもね

行列演算を並列処理とかそういう粒度の細かな並列化の話ばっかりで。
せっかく10コアとかあるんだから、各コアに別々のプログラムを走らせておいて
同期しながら処理とかしたいんだけどどうするのがいいかよく分からない。
fork させてメッセージやりとりすれば良さそうなんだけど。
やりたいことがちょっと特殊かもね。

質問の低レベル化が甚だしい。アセンブラを勉強して基礎固めを。

OpenMPみたいなのを手動でやるって話かな
マルチコアだとメモリ帯域がボトルネックになりやすいから
巨大な行列計算は少し粒度を荒くしたMPIの方が強いよね

10コアとかいってるからマルチプロセッサというよりメニーコア活用術？

>>433
むしろアセンブラのほうが分かりやすいんだけど。

各コアにPCセットして起動すればいいの？
プロセッサの仕様書読んでみるわ。

並列処理じゃなくて並行処理で探せば

マルチスレッドの排他処理で詰まってスレ検索して来てみたけどこのスレは高尚過ぎるなｗ
初心者スレにでも行こう

_beginthreadex() を使ったマルチスレッドプログラムについて質問です。
この関数の説明を見ると、「_beginthreadex() のコールに成功すると、スレッドのために
タイムスライスが割り当てられたか否かによらず、スレッドはアクティブ(non-signal)になる」
とあったのですが、_beginthread() がスレッドハンドルを返すよりも前にスレッド関数内の
処理が実行される（完了する）ことはありえますか？

>成功した場合、これらの各関数は、新しく作成されたスレッドへのハンドルを返します。ただし、新しく作成されたスレッドが短時間で終了した場合、 _beginthread は有効なハンドルを返さない可能性があります。 (「解説」の説明を参照してください)。

>_Beginthread よりも _beginthreadex を使用する方が安全です。 _Beginthread によって生成されるスレッドが短時間で終了した場合は、 _beginthread の呼び出し元に返されるハンドルが無効であるか、別のスレッドを指している可能性があります。 ただし、 _beginthreadex によって返されるハンドルは _beginthreadex の呼び出し元によって閉じられる必要があるため、 _beginthreadex がエラーを返さなかった場合は、有効なハンドルであることが保証されます。


ハンドルが有効であることは保証されているけど
実行順についての言及はないし、
そもそも別スレッドなら、どちらが先に行われるかについては何の保証もないと考えるべきじゃないのかな
「APIから戻る」のだって実行権がなければ後回しにされる可能性はあるんだから

>>440
ご返信ありがとうございます。概ね理解できました。
勉強不足で、マルチスレッドの仕組みについて誤解していたようです。

ちなみにCentOSはスレッドのコアが指定できるよ。

macOSだとコア指定できない。

あわしろ氏によると、Macは既にオワコンなので、WSLを使うと良いらしい。

針に糸を通す( thread a needle
糸をつむぐ( spin thread [yarn]
糸が切れた( The thread broke.
琴の糸を締める( tighten a string of a koto
糸をかき鳴らす( strum the strings

このスレ来年で10年か
スレ推奨図書とかないの？

マルチスレッド処理の花形といえばハードなリアルタイムスレッドとバックグラウンドスレッドの間のデータのやり取りだと思ってるんだが
スレの過疎っぷりを見るに、殆どの人にとって必要のないものだったんだな

>>447
MS-DOS のデバイスドライバにでも痕跡が残っていたような‥
どうするつもりだったんだろう？

>>447
ハードな略が動いている間はバック略を動かさないから大して考えることは無い
DOSの頃と同じだな

>>432
　とりあえず、メインスレッド1個にサブスレッドを9個用意し、基本的な管理はメインスレッド管理。
イベントハンドルは９×２個用意する。

　サブスレッドはイベント処理とWaitForSingleObjectで待たせておいて、メインスレッドから情報を送って
SetEventでイベントを動かす。メインスレッドはサブスレッド９個からSetEventでイベントが返らない限り
イベントとWaitForSingleObjectを駆使して止めておく。

>>432
　とりあえず、メインスレッド1個にサブスレッドを9個用意し、基本的な管理はメインスレッド管理。
イベントハンドルは９×２個用意する。

　サブスレッドはイベント処理とWaitForSingleObjectで待たせておいて、メインスレッドから情報を送って
SetEventでイベントを動かす。メインスレッドはサブスレッド９個からSetEventでイベントが返らない限り
イベントとWaitForSingleObjectを駆使して止めておく。

>>450-451
あ”、二重投稿になったか。

えっと、ちょっと補完。
サブスレッドの処理についてはループして待たせておく。終わったら終了を知らせるイベントを発生させる。

＞＞３６５
REID 1 みたいな例があるから必ずしも昔の技術というわけではないな。

>>16
　あれって、ＯＳの機能だから気にしなくても良いというのでは駄目か？