トップページ⇒tech
1001コメント278KB

C#, C♯, C#相談室 Part43

■ このスレッドは過去ログ倉庫に格納されています
0001デフォルトの名無しさん2007/09/27(木) 07:17:16
(#゚ー゚)つ < C#、.NETの話題はこちらでどうぞ。

前スレ
C#, C♯, C#相談室 Part42
http://pc11.2ch.net/test/read.cgi/tech/1188099745/
0153デフォルトの名無しさん2007/10/07(日) 16:57:54
適当な大きさにバッファリングされたファイルストリームを使ってるなら、
1文字ずつ読んで比較してもさほど時間は変わらないと思うけどな。
一度にバイト配列に読み込んでメモリに入りきらないほどのサイズだったらどうするのよ。
01541482007/10/07(日) 17:04:42
> 一度にバイト配列に読み込んでメモリに入りきらないほどのサイズだったらどうするのよ。
どうしよう・・・

ってことでFileStream.ReadByte()を使って1バイトずつ
比較して合致しなかったらreturn falseっていう方法が
妥当だと考えましたがいかがでしょうか。
0155デフォルトの名無しさん2007/10/07(日) 17:11:06
>>154
BinaryReader(new BufferedStream(new FileStream(file, ...)))
01561482007/10/07(日) 17:11:59
ちなみに今一度全部バイト型配列にRead()で読み込んで比較する方法と
一バイトずつReadByte()で比較する方法を
Stopwatchクラスで計ったら1msしか違いは出ませんでした。
テストしたファイルは9118バイトで(小さいかも)378msです。

というとことは、これでReadByte()でOKかも
0157デフォルトの名無しさん2007/10/07(日) 17:16:48
なんかすごい低レベルの議論だな。。

>>154
別に一度に配列に全部よまなくても、「適当なサイズ」の配列に読めばいいでしょ。
どのぐらいの大きさが「適当なサイズ」かは判断が難しいところだろうけど。

実際に確認したわけじゃないけど、普通に考えればストリームがいくらバッファリング
されているからといって、配列と同じ効率でアクセスできるとは考えにくいから、
配列に一度読み出すことには意味があると思う。

それに、これも実際に確認したわけじゃないけど、
そんなことより>>152の言ってる事の方が恐らく重要。
0158デフォルトの名無しさん2007/10/07(日) 17:19:11
ファイルアクセスの方が圧倒的に遅くなるのは当たり前田のコンコンチキじゃないか?
0159デフォルトの名無しさん2007/10/07(日) 17:30:48
>>155
FileStream自体がバッファを持ってるからBufferedStreamはいらないか。
標準で8K、サイズはコンストラクタでも指定できるそうだ。
BinaryReaderは一応使っといて。
0160デフォルトの名無しさん2007/10/07(日) 17:31:19
ファイル全部読み出す時間に比べたら
比較にかかる時間なんて誤差の範囲
終了
0161デフォルトの名無しさん2007/10/07(日) 18:46:17
いちいち1バイトずつ比較するよりも数十KB単位でMD5出した方が速いような気がするのは俺だけ?
小さいの(数KB)ならいいかもしれんが。
0162デフォルトの名無しさん2007/10/07(日) 18:48:04
おまいだけ
MD5じゃコリジョンが発生しうる
0163デフォルトの名無しさん2007/10/07(日) 18:55:29
>>161
特に問題ないからそれでいいと思うよ
0164デフォルトの名無しさん2007/10/07(日) 19:16:26
MD5ったって一バイトずつ見てかないと計算できないだろ・・・
0165デフォルトの名無しさん2007/10/07(日) 19:18:52
MD5出すなら比較した方が早い
01661482007/10/07(日) 19:22:38
148です。
1.5MBのテキストファイルを1バイトずつ計算したら63000msかかり
けっこう使い物にならないかも・・・

とにかく早い比較方法はないでしょうか。
MD5?調べてみます。
0167デフォルトの名無しさん2007/10/07(日) 19:24:36
読み出しだけの時間と比較しなさいよ
0168デフォルトの名無しさん2007/10/07(日) 19:26:19
1対1の比較ならMD5は不要だけれども
1対多数を比較するならMD5がいいね
0169デフォルトの名無しさん2007/10/07(日) 19:33:25
1対多でもハッシュは無用
多対多ではすごく有用
0170デフォルトの名無しさん2007/10/07(日) 19:36:03
てか同じじゃないのを同じと判断する確率が
約1/2^128 あるでしょ
0171デフォルトの名無しさん2007/10/07(日) 19:36:19
aho
0172デフォルトの名無しさん2007/10/07(日) 19:38:09
>>169
1対多でも有用ですよ
0173デフォルトの名無しさん2007/10/07(日) 19:41:01
>>166
>1.5MBのテキストファイルを1バイトずつ計算したら63000ms
あり得んよ。一体どんなコード書いたの?
0174デフォルトの名無しさん2007/10/07(日) 19:47:30
>>172
n回ハッシュ計算するのとn回バイト列の比較するのとどっちが効率いいと思う?
0175デフォルトの名無しさん2007/10/07(日) 19:49:58
ヒント:メモリの効率
0176デフォルトの名無しさん2007/10/07(日) 19:53:29
どう有用なのか教えてくれ。
ってか1対多って、ひとつのファイルを、複数のファイルそれぞれと比べてって話でいいんだよな?

しかしこういう時すぐにハッシュを出してくるやるはどういう発想なんだ?
多対多とかの話は別だが、単に2つのファイルの比較でもすぐに言い出すやつが出る。

0177デフォルトの名無しさん2007/10/07(日) 19:54:54
メモリマップしてメモリ比較でいいんじゃねww
0178デフォルトの名無しさん2007/10/07(日) 19:55:53
>>174
一つのファイルから1回読み込むのとn回読み込むのとどっちが効率いいと思う?
0179デフォルトの名無しさん2007/10/07(日) 19:56:28
ハッシュ計算するにも結局全バイト舐める必要があんだろ
何にもかわらんと思うが

それより、ReadByte()でバイト読みするんなら、せめてBufferedStream()
使うべきじゃね
0180デフォルトの名無しさん2007/10/07(日) 19:58:07
そのまんまメモリ上に置いても大丈夫なくらい小さいファイルならハッシュ使わなくていいんじゃない
0181デフォルトの名無しさん2007/10/07(日) 20:01:12
ていうかな、ハッシュだけ残して比較しようとしたら、一バイト目で違っても全部読まなきゃならないんだぞ。
あふぉか?
0182デフォルトの名無しさん2007/10/07(日) 20:02:09
BufferedStream
いらんて話がとうに出とろうがw
01831482007/10/07(日) 20:29:00
148っす
こんなコードです。
FileStream fs1 = new FileStream(path1, FileMode.Open, FileAccess.Read);
FileStream fs2 = new FileStream(path2, FileMode.Open, FileAccess.Read);
if(fs1.Length != fs2.Length){
return false;
}
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
//How to 1
byte[] bt1 = new byte[fs1.Length];
byte[] bt2 = new byte[fs2.Length];
fs1.Read(bt1, 0, (int)fs1.Length);
fs2.Read(bt2, 0, (int)fs2.Length);
Console.WriteLine("読み出し完了" + stopWatch.ElapsedMilliseconds.ToString());
for(int i = 0; i< fs1.Length; i++){
if(bt1[i] != bt2[i]){
Console.WriteLine("見っけ"+stopWatch.ElapsedMilliseconds.ToString());
//return false;
}
}
stopWatch.Stop();
Console.WriteLine("How To 1 全部で" + stopWatch.ElapsedMilliseconds.ToString());
stopWatch.Reset();
fs1.Seek(0, SeekOrigin.Begin);
fs2.Seek(0, SeekOrigin.Begin);
01841482007/10/07(日) 20:29:44
続きっす
stopWatch.Start();
//How to 2
for (int i = 0; i < fs1.Length; i++) {
if (fs1.ReadByte() != fs2.ReadByte()) {
Console.WriteLine("見っけ" + stopWatch.ElapsedMilliseconds.ToString());
//return false;
}
}
stopWatch.Stop();
Console.WriteLine("How To 2 全部で" + stopWatch.ElapsedMilliseconds.ToString());
fs1.Close();
fs2.Close();
01851482007/10/07(日) 20:30:16
ちなみにHowTo1の二つのファイルをバイト配列に読み込んだ段階で
だしたログが
>読み出し完了7ms
で7msだったのが意味わからんかったです。つまり実際byte配列には
ポインタのようなものだけ与えてるってことでしょうか。
その後は
>見っけ57491
>How To 1 全部57493
>見っけ65137
>How To 2 全部65138
って感じですけど、この全部ってのは1が早くなったり2が早くなったり
ほぼ同じくらいになったりします。
0186デフォルトの名無しさん2007/10/07(日) 20:33:27
> ちなみにHowTo1の二つのファイルをバイト配列に読み込んだ段階で
> だしたログが
> >読み出し完了7ms
> で7msだったのが意味わからんかったです。つまり実際byte配列には

たぶんキャッシュされてるのを持ってきてる
0187デフォルトの名無しさん2007/10/07(日) 20:35:10
異なるバイト列から作ったMD5のハッシュが衝突する可能性は無いものと考えていい
0188デフォルトの名無しさん2007/10/07(日) 20:37:25
見た感じだけだとfs1.Lengthが遅いんじゃないかな
0189デフォルトの名無しさん2007/10/07(日) 20:39:27
>>184-185
遅いのは毎回ストリームからLengthプロパティを取得してるからだよ。
0190デフォルトの名無しさん2007/10/07(日) 20:44:33
>>187
おいおい……
01911482007/10/07(日) 20:46:10
あっ!!!
確かに!!

今Lengthプロパティを変数にいれてfor文回してくるんで
ちょっと待っててください!!
0192デフォルトの名無しさん2007/10/07(日) 20:46:14
もう一荒れする予感
0193デフォルトの名無しさん2007/10/07(日) 20:49:53
How To 1って
0194デフォルトの名無しさん2007/10/07(日) 20:51:33
時間かかるような処理をプロパティにしないでもらいたいものだ
0195デフォルトの名無しさん2007/10/07(日) 20:57:07
だからそんな小手先のことより>>152の指摘の方がずっと重要だっつーのにw
CPUがデータバスの本数を増やしてきた歴史を何だと思ってるんだよ
0196デフォルトの名無しさん2007/10/07(日) 20:58:47
てかバイト配列を一気に比較したりするメソッドって
なんかなかったっけ
01971482007/10/07(日) 21:00:35
結果です。すいませんでした。

読み出し完了8
見っけ19
How To 1 全部で19
見っけ103
How To 2 全部で103

超早かったです・・・。1.5Mbの5万行のコード比較でした。
ちなみに間違った行は49999行くらいにいれてます。
この速さなら全然要望通りです。

しかもこれだと結局バイト配列に入れた方が結局早いってこと?
バイト配列ってどのくらい読み込むことできるんでしょうか。

> How To 1って
そこは触れないでください。

> 時間かかるような処理をプロパティにしないでもらいたいものだ
この50近いスレ汚しをどう償えばいいでしょうか。
0198デフォルトの名無しさん2007/10/07(日) 21:04:22
だから最初から要ってるじゃん。
いくらバッファリングされてるといっても配列の効率に敵うはずがないって。
だからそんなことより>>152の指摘の方がずっとw
01991482007/10/07(日) 21:08:31
>だからそんな小手先のことより>>152の指摘の方がずっと重要だっつーのにw
>CPUがデータバスの本数を増やしてきた歴史を何だと思ってるんだよ
それはRead()メソッドのときに4バイトずつ読み込んで
byte配列[4]をuintにシフトして代入して比較するということで
合っていますか?
0200デフォルトの名無しさん2007/10/07(日) 21:09:38
違います
02011482007/10/07(日) 21:13:40
むぅ。ということは

>いくらバッファリングされてるといっても配列の効率に敵うはずがないって。
を踏まえると、配列に全部読み込んで
そこから4バイトずつでuintに代入して4バイトごと比較する!
もしくはUINT64!?
0202デフォルトの名無しさん2007/10/07(日) 21:15:20
もしかしたらbyte配列の比較も最適化されてるかもしれないし
02031482007/10/07(日) 21:20:31
一応プロジェクト-プロパティ-ビルドタブの
コードを最適化するチェックボックスを外してたんですが
ここは関係ないですか?
0204デフォルトの名無しさん2007/10/07(日) 23:48:07
バイト配列を作らないで4バイトずつ比較

bool Hikaku(string file1, string file2)
{
using (FileStream fs1=new FileStream(file1, FileMode.Open))
using (BinaryReader br1=new BinaryReader(fs1))
using (FileStream fs2 = new FileStream(file2, FileMode.Open))
using (BinaryReader br2=new BinaryReader(fs2))
{
if (fs1.Length != fs2.Length) return false;
long num = fs1.Length / 4;
for (long i = 0; i < num; i++)
if (br1.ReadUInt32() != br2.ReadUInt32())
return false;
num = fs1.Length % 4;
for (long i = 0; i < num; i++)
if (br1.ReadByte() != br2.ReadByte())
return false;
return true;
}
}

60MBのファイルで2秒ぐらいかかった。
1バイトずつ比較しても速度が同じだったんで最適化される模様。
0205デフォルトの名無しさん2007/10/07(日) 23:51:50
byte[] から int* で読んでくのがたぶん最速だろうけど
0206デフォルトの名無しさん2007/10/07(日) 23:53:10
まあReadByteが遅いのは仕方が無い。

バスがどうこうとかいう問題じゃないけどな。
単純に無駄な処理が多すぎるから。

Readで適当なサイズのバッファに読み込んで、
forで同じように比較してもぜんぜん変わるだろう。
ただし4バイトとかだと多分まだ無駄が多いと思う。
どのくらいがいいかはなんともいえんけど、
適当なサイズで試して、大きく改善される範囲で適当にきめたらいいだろう。
数十から数百バイト以上まとめたらもうそんなに変わらんのじゃないかな、わからんけど。
0207デフォルトの名無しさん2007/10/07(日) 23:54:05
そんなちょっと読むのにBinaryReaderとかかましたら余計遅くなるんで無いの
02082042007/10/07(日) 23:56:13
60MBのファイルをバイト配列に読み込んだら一瞬だった。
ただ、メモリ食いすぎるが。
ちなみにStirlingっていうバイナリエディタのバイナリ比較を試したら3秒かかった。
0209デフォルトの名無しさん2007/10/07(日) 23:56:28
4バイト処理するだけに無駄なことしすぎ。
0210デフォルトの名無しさん2007/10/07(日) 23:56:57
unsafeで書けよ
0211デフォルトの名無しさん2007/10/07(日) 23:57:11
>60MBのファイルをバイト配列に読み込んだら一瞬だった。
明らかにキャッシュされてるっての。
0212デフォルトの名無しさん2007/10/07(日) 23:57:50
どんなディスクだよっ
0213デフォルトの名無しさん2007/10/07(日) 23:58:54
>>211
バイナリエディタでファイルの末尾だけ弄ってるんだけどそれでもだめ?
0214デフォルトの名無しさん2007/10/08(月) 00:00:12
だめ。
ってか一瞬てどれくらい?
0215デフォルトの名無しさん2007/10/08(月) 00:04:54
>>214
同じぐらいサイズの別のファイルで試してみた900�_秒ぐらい。
02161482007/10/08(月) 00:19:30
148です
もう一度Read()でバイト配列の比較と一バイトずつのReadByte()比較を
テストしてみたらReadByte()の方が早いという結果が出ました。
50MBのバイナリファイルで
前者が3190ms
後者が2743ms
そして204の言うとおりメモリ食いすぎなので、どっちもこれだけ早いなら
超巨大なファイルが来たときのことを考えて、
ReadByte()で1バイトずつ比較した方がいいのかも。

てかWinMergeですら同じ条件で3秒くらいかかるからもういいかなぁ
02172042007/10/08(月) 00:22:15
>>216
これで60MBのファイルが600ミリ秒になったよ。


64KBずつ配列に読んで比較。

using (FileStream fs1=new FileStream(file1, FileMode.Open))
using (FileStream fs2 = new FileStream(file2, FileMode.Open))
{
if (fs1.Length != fs2.Length) return false;
int num = (int)fs1.Length;
byte[] data1 = new byte[num];
byte[] data2 = new byte[num];
int read;
while (true)
{
if (fs1.Position == fs1.Length) return true;
read = fs1.Read(data1, 0, 1024 * 64);
fs2.Read(data2, 0, 1024 * 64);
for (int i = 0; i < read; i++)
if (data1[i] != data2[i])
return false;
}
}

02182042007/10/08(月) 00:26:56
あ、new byte[num] は 1024*64 です。
02191482007/10/08(月) 00:36:37
>> 218
ありがとうございますっ!

それなら最速で4GBファイルとか来ても大丈夫ですね。
それでいきたい思います。

皆様本当にありがとうございました。
0220デフォルトの名無しさん2007/10/08(月) 00:49:46
System.Array.Equals
0221デフォルトの名無しさん2007/10/08(月) 00:53:35
どういたしまして
がんばってね^^
02221482007/10/08(月) 01:02:44
>>217
すいません。20秒かかるのですが、どこか間違ってますか?
int last = (int)fs1.Length;
byte[] data1 = new byte[1024 * 64];
byte[] data2 = new byte[1024 * 64];
int read;
int sumRead = 0;
while (true) {
if (sumRead == last) {
break;
}
read = fs1.Read(data1, 0, 1024 * 64);
sumRead += read;
fs2.Read(data2, 0, 1024 * 64);
for (int i = 0; i < read; i++) {
if (data1[i] != data2[i]) {
fs1.Close();
fs2.Close();
return false;
}
}
}
02231482007/10/08(月) 01:05:38
>>217
のコードで
if (fs1.Position == fs1.Length) return true;
は64KBごとに2つプロパティを参照するから20秒かかるかなぁ
と思ってsumReadとlastに変えてみたのですが、
変わりませんでした。

???
0224デフォルトの名無しさん2007/10/08(月) 01:15:35
キャッシュされてないファイルを読み込んだからじゃない?
0225デフォルトの名無しさん2007/10/08(月) 01:20:45
>>216
なんでいきなりそんなに変わったんだ?
あ、サイズ大きくしたら逆転したってことか?
0226デフォルトの名無しさん2007/10/08(月) 01:25:08
>>223
そのコード、break後が不明なんで
勝手にreturn trueを補ったけど早かったよ。


何度やっても遅いのならキャッシュじゃない気がする。
02271482007/10/08(月) 01:47:27
>>226
>そのコード、break後が不明なんで
>勝手にreturn trueを補ったけど早かったよ。
break後ファイルCloseしてreturn trueだけなので
変わらないと思います。

何度やっても遅かったからよくわからないです。
すいません、今日はもう限界なので明日またがんばります。

>>225
何ででしょう。結局ReadByte()ってそんなに遅くないって
ことなんでしょうか。

0228デフォルトの名無しさん2007/10/08(月) 01:56:08
まとめて読むよりは確実に遅いと思うが、
それは無駄な処理が多いからであって、
バッファされないとかそういう極端な差は無い。
結局IOが重過ぎてその程度の無駄な処理は
ほとんど影響ないってことかもね。
0229デフォルトの名無しさん2007/10/08(月) 02:02:47
>>227
ReadByte()も内部ではバッファに一度4KB読み込んでその配列から1バイトずつ返している
だけみたいだから、大して遅くはならないんじゃないか。
むしろRead()の方は結構面倒くさい処理を内部でやっているっぽい。幾つかの例外処理とか
配列のコピー処理とか。
0230デフォルトの名無しさん2007/10/08(月) 03:32:35
スレチだが、最近のスレ見てて思い出したので質問させてくれ。
パフォーマンス計測してて、
キャッシュをクリアしたいと思ったとき、
OS再起動してるんだ。もしくは、
メモリ量と同じサイズのファイルを読み込む
ことでもクリアと同等の意味を持つと思ってる。
もっとお手軽な方法ないのかな?
0231デフォルトの名無しさん2007/10/08(月) 03:36:57
キャッシュってどれの事?
0232デフォルトの名無しさん2007/10/08(月) 03:50:00
IO系のキャッシュでそ。
02332302007/10/08(月) 03:52:00
たぶんシステムキャッシュだとおもう。
2回目以降のファイル読み込みが早くなるやつだ。

もっと正確にいうなら、
自作アプリのパフォーマンス計測する際に
何度か計測するが、キャッシュが効いてると
1回目と2回目以降の計測はあきらかに条件がこと
なってしまう。できるかぎり同じ条件で
計測したいってことなんだが。
良い方法ないだろうか?
0234デフォルトの名無しさん2007/10/08(月) 04:37:46
ファイルコピーして消せばいいんじゃねえの
0235デフォルトの名無しさん2007/10/08(月) 10:05:34
キャッシュが利かないときが20秒でキャッシュが利くと1秒以下
1バイト比較でも配列にバッファリングしてもたいした差はでないね〜

こういう配列の比較は
for (int i = 0; i<rsize1; i++) if (buf1[i] != buf2[i]) return false;
アンセーフ使うと早くはなるのは確認
unsafe {
 fixed (byte * fp1 = &buf1[0])
 fixed (byte * fp2 = &buf2[0]) {
  byte * p1 = fp1; byte * p2 = fp2;
  for (int i = 0; i<rsize1; i++) if (*p1++ != *p2++) return false;
}}
非同期IOも使ってみたが効果なしだった
0236デフォルトの名無しさん2007/10/08(月) 10:09:57
http://www.microsoft.com/japan/msdn/community/gdn/ShowPost-31903.htm
これと同じ事かな

リンク先では解決してないっぽいね
0237デフォルトの名無しさん2007/10/08(月) 10:26:38
結局int*にしたら早くなるの?
0238デフォルトの名無しさん2007/10/08(月) 10:27:50
メモリクリーナ系のツール実行が一番手っ取り早いんでない?やっぱり。
0239デフォルトの名無しさん2007/10/08(月) 10:42:10
>>237
早くなる。
ただし末尾が余る(ことがある)ので気をつける必要がある。
02402302007/10/08(月) 11:39:34
>>234
いや。すでにあるファイルのリード系という前提で話してるから
それは使えない。

>>236
リンク先の質問と趣旨は違ってるけど、やりたいことは同じなので
ビンゴですね。でもM$の中の人が、
>システム ファイル キャッシュだけを解放するような手段は聞いたことがありません
って書いてるので、正攻法としてはできないっぽいですね(泣

>>238
メモリクリーナー系
いまいち何やってるかわからないので敬遠してたんだ。

いろいろさんきゅー
0241デフォルトの名無しさん2007/10/08(月) 11:47:35
メモリクリーナは、超大量のメモリを確保することで
ほかのメモリを強制的にスワップアウトさせてる。
たぶんシステムキャッシュもクリアされるだろうけどどうかな?
02422042007/10/08(月) 15:04:09
4GBのファイルを二つ作ってやってみたよ。
大体一秒で10MB処理できる感じ。
なので>>217はキャッシュが効いているみたいだね。
実際に、4GB読み込んだ後に行ったら6秒かかった。
>>222との差は環境の差なのかもしれない。
うちの環境はSATAIIのHDDに2GBのメモリです。

maxBufSize以下のファイルサイズなら一括読込。それ以上なら分割読込するようにしてみた。
仮に100MBにしてあげると60MBのファイルは2.5秒で終りました。

using (FileStream fs1 = new FileStream(file1, FileMode.Open))
using (FileStream fs2 = new FileStream(file2, FileMode.Open))
{
if (fs1.Length != fs2.Length) return false;
long last = fs1.Length;
int maxBufSize = 好きな数字を入れるだけ;
int bufsize = fs1.Length > maxBufSize ? maxBufSize : (int)fs1.Length;
byte[] data1 = new byte[bufsize];
byte[] data2 = new byte[bufsize];
int read;
long sumRead = 0;
while (true)
{
if (sumRead == last) return true;
read = fs1.Read(data1, 0, bufsize);
sumRead += read;
fs2.Read(data2, 0, bufsize);
for (int i = 0; i < read; i++)
if (data1[i] != data2[i])
return false;
}
}
02431482007/10/08(月) 17:06:52
>>242
ありがとうございました。色々試して
自分も50MBのファイルが2.3秒くらいでできました。
これでOKです!
本当に親身になって頂きありがとうございました。

0244デフォルトの名無しさん2007/10/08(月) 17:10:11
何回もfs1.Lengthを呼ぶなっちゅーに
0245デフォルトの名無しさん2007/10/08(月) 17:17:28
たしかにlastで補えるな。
まぁ毛の先ほども皮欄だろうが。
0246デフォルトの名無しさん2007/10/08(月) 17:25:10
byte[]をint*にキャストする話はどうなったんだ
0247デフォルトの名無しさん2007/10/08(月) 17:29:41
非同期読み込みを使う話もまだ出てきていないよな。
0248デフォルトの名無しさん2007/10/08(月) 17:30:55
ファイル読み込みにかかる時間に比べたら
比較にかかる時間なんてわずかだから
非同期にしたところでたいした違いはないと思うけどな
0249デフォルトの名無しさん2007/10/08(月) 17:38:09
非同期をなんか勘違いしてないか?
って気がするよな。

そもそも単純なスループットは非同期の方が悪いんじゃなかったかな?
0250デフォルトの名無しさん2007/10/08(月) 17:40:10
どう考えてもボトルネックは記憶デバイスの読み込み速度なんだから、
どれだけシークを少なくするかにかかってるんじゃね?
0251デフォルトの名無しさん2007/10/08(月) 17:41:13
I/Oでボトルネックになってるんだったら、非同期でI/Oしながら読んだ部分から処理していくのは正しい処理。
0252デフォルトの名無しさん2007/10/08(月) 18:13:16
確かにnバイトディスクから読むときの時間とnバイトのコンペアに掛かる時間が
イコールの時には効率上がりそうだけど、問題はその効率を最大化するnが
環境によって大きく異なることが予想される上に計算可能性が低い(ない?)ことか?
■ このスレッドは過去ログ倉庫に格納されています