【雑談】 floatはdoubleより高速だと考えている人はどれぐらいいますか？

[たかぎ]

似たような雑談スレばかり立ててすみません。

floatはdoubleより高速だと考えている人はどれぐらいいますか？

皆さんご自身のことや周りの状況など、何でもよいので情報をください。

[Ma]

どこかで、float は double より遅いとかって見たことがあるような・・・。
そんな感じのあいまいな認識ですが、double ほど精度がいらないときはfloatを使う事は結構あります。
どこかでそれを読むまでは単純にデータ長が短いから高速と思っていました。

[ムンバ]

同一ファイル内での出来事ですよね？
同一ファイル内だとして、型の宣言の順番とかも関係してくるのでしょうか？

使用条件が同じ環境で、型宣言（同一bit？で）の順番も同じ条件とすると・・・
（何か勘違いしてたら、申し訳御座いません。）

float　の方が・・・処理速度の事ですよね？＜速いと思います。

それぞれ、型宣言した変数の値（のbit数？）にも影響されると思うのですが・・・。
と、現時点では思います。

[たかぎ]

> Maさん

> どこかで、float は double より遅いとかって見たことがあるような・・・。

↓でしょうか？
http://www.pro.or.jp/~fuji/mybooks/cdiag/cdiag.4.4.html

> どこかでそれを読むまでは単純にデータ長が短いから高速と思っていました。

実測されたこと、あるいはコンパイラの出力を確認したことはありますか？

[たかぎ]

> ムンバさん（寝たのでは？）

> 同一ファイル内での出来事ですよね？

同一ファイルかどうかとかは考えたこともありませんでした。

> 同一ファイル内だとして、型の宣言の順番とかも関係してくるのでしょうか？

型の宣言といっても、floatもdoubleも組み込み型ですが...

> float　の方が・・・処理速度の事ですよね？＜速いと思います。
> それぞれ、型宣言した変数の値（のbit数？）にも影響されると思うのですが・・・。
> と、現時点では思います。

要するにfloatのほうが高速だということですね。

[Justy]

　環境によりけりなんでしょうけど、私の扱った・知っている狭い範囲の中だけでいうと
多くの環境で floatの方が高速に処理されるという印象はあります。


　最初に扱ったプラットフォームは sizeof(float) == sizeof(double) でどう書いても単精度として
扱われる環境だったこともあり、そのあたりは全く気にしていませんでした。

　次のプラットフォームでは double型が倍精度になりソフトウェア演算になった為 double型の演算が
激重になりました。
　後から知ったのですが、最初の環境もコンパイラオプションで切り替えできるらしく、
単精度化オプションを外せばきっと最初の環境も遅くなっていたでしょう。


　今の Windows + Intel CPUの場合ですと普通に使っている限り演算そのものの速度は全く変わらない
（或いは多少違いはあっても気にしなければならないレベルではない）と思っています。

　ただ、FPUのレジスタを変更して精度を下げた場合は floatの演算が速くなる（と言われていますが
テストしたことはありません）ということと、メモリアクセスが絡む場合（特に大量の）floatと doubleでは
単純に倍の領域にアクセスが必要になる、という２点において floatの方が高速になることがあると
思っています。

[たかぎ]

> Justyさん

なるほど。
速度に関していえば、double ≦ float だということですね。
そして、環境に依存すると。

doubleの方が高速になる可能性はないでしょうか？

[Justy]

＞doubleの方が高速になる可能性はないでしょうか？
　うーん、そうですね。

　先の「Ｃプログラミング診断室」で説明されている「HW/コンパイラ的に doubleの方が効率よく処理する」
ケースくらいしかちょっと思いつかないです……。

　思いついたら、また書き込みます。

[Ma]

>実測されたこと、あるいはコンパイラの出力を確認したことはありますか？
ないですね。勝手な憶測です。

[ookami]

ちょっとそれるかも分かりませんが、cosf(ang) が (float)(cos(ang)) と定義されていてビックリしたことがあります。わざわざdoubleで計算してからfloatに落としているのかと。それで漠然と、doubleの方が速いのかなと思ってました。

[たかぎ]

> ookamiさん

> ちょっとそれるかも分かりませんが、cosf(ang) が (float)(cos(ang)) と定義されていてビックリしたことがあります。わざわざdoubleで計算してからfloatに落としているのかと。それで漠然と、doubleの方が速いのかなと思ってました。

これは実装上の手抜きですね。
ただ、それが原因でdoubleの方が高速に処理できるということは確かにありそうです。

[Dixq (管理人)]

この件は、Cを学び始めたころ、たまたまネットでdoubleの方が早い事が多いという記事を見かけて知りました。

後、龍神録を作ってるときに何回も計った覚えがあります。
結果、ほとんど変わらないか、doubleの方が微妙に早いという印象でした。
（まぁ後になってJustyさんからDirectXではdoubleの精度はfloatと同じになると教えて頂く事になるわけですが・・）

今も計ってみました。

●　コンソールプログラム　●

t=clock();
for( i=0; i<1000000000; i++ ){
f+=1.1f;
}
printf("%d - %f\n",clock()-t,f);
t=clock();
for( i=0; i<1000000000; i++ ){
d+=1.1;
}
printf("%d - %f\n",clock()-t,d);

実行結果

3104 - 33554432.000000
3086 - 1100000014.151283


●　DXライブラリプログラム　●

t=GetNowCount();
for( i=0; i<1000000000; i++ ){
f+=1.1f;
}
printfDx("%d - %f\n",GetNowCount()-t,f);
t=GetNowCount();
for( i=0; i<1000000000; i++ ){
d+=1.1;
}
printfDx("%d - %f\n",GetNowCount()-t,d);

実行結果

3071 - 33554432.000000
3049 - 33554432.000000


DirectXにおいても微妙にdoubleの方が早いのはそのままなんですね。
まぁこれ位の差はほぼ無いに等しいでしょうけど。

CPU : i7 860
コンパイラ ： VC++2008Express

[たかぎ]

> Dixqさん

> DirectXにおいても微妙にdoubleの方が早いのはそのままなんですね。
> まぁこれ位の差はほぼ無いに等しいでしょうけど。

これは有意な差とは言いにくいですね。

[ねこ]

「float>=double」の認識が強いです。

DirectXの関数で使われてたり、３Ｄライブラリでもfloatを使うよう示唆していたりするための先入観です。
なのでずっとfloatの方が高速という印象を持っていました。
以前気になってネットで調べると最近？では大差が無いという記事を見つけたので「>=」という認識になっています。
「昔はfloatの方が高速だった」のではないか、という考えになりました。

きゅーさんのレス見てて思ったのが何において高速と判断するかでしょうか。
例えば1.1の加算を行っていますが、例えばこれが浮動（固定）小数点同士の乗算や除算、浮動小数点と整数型の演算になると差が出るのかなと。
また32ビット環境においてfloatは4バイトdoubleは8バイトという差もあるので当然メモリの生成速度？は倍変わるのかな等。
※32ビット環境以外は無知です。

演算においては恐らく同等
サイズの関係で深く大きいシステムにおいては「float>double」になるのではないか
という見解です。

ちなみに個人的にはfloatは演算誤差でバグ起こすイメージがあるのでほぼ使わない型です。

[たかぎ]

> ねこさん

> 「float>=double」の認識が強いです。

これは、IntelのCPUかつWindowsの場合に限った話でしょうか？

> 「昔はfloatの方が高速だった」のではないか、という考えになりました。

例えばSSEが単精度しか使えないとか、現在ほどメモリが潤沢ではないので、頂点情報などをdoubleで持つとサイズ的に許容できないとか、あるいはキャッシュミスヒットやページフォルトが頻繁に発生するとか、そういうことでしょうかね。

> 例えば1.1の加算を行っていますが、例えばこれが浮動（固定）小数点同士の乗算や除算、浮動小数点と整数型の演算になると差が出るのかなと。

四則演算の中では最も時間がかかる除算を使えば、もう少し差を確認しやすいかもしれませんね。

[toyo]

結局コンパイラやFPUユニットなどの環境次第ではないかと考えてます
全部ソフトウェアで計算するならfloatの方が早い
double精度に適したfpuプロセッサならdoubleの方が早い

昔のPC9801がFPUコプロセッサが別売でしかもかなり高価だったのを思い出しました

[ねこ]

＞たかぎさん

＜これは、IntelのCPUかつWindowsの場合に限った話でしょうか？
特にOSやCPUの規格を意識していないです。
自身で一番多い開発環境がWinXPでのVC6～2008で、それ以外の環境でどうこうまでは考えていません。

WinOS、VC使いが、Windows上でだけ動かすものを作るために考えた結果という認識でお願いします。

[たいちう]

> > どこかで、float は double より遅いとかって見たことがあるような・・・。
>
> ↓でしょうか？
> http://www.pro.or.jp/~fuji/mybooks/cdiag/cdiag.4.4.html

私も多分その本かサイトで知りました。
その本も古い本ですが、もっと古い時代にはfloatの方が確実に速く、
それが常識として定着していたのでしょう。

重要なのはそのような常識は変わりうる、という事を意識しておくことと思い、
最終段階で必要に迫られたとき以外は、そのような最適化はしません。
当然、その時は実測しながらです。

ある程度以上の大きさのnに対してなら、O(n^2)よりO(n*log(n))が速いという
常識が覆ることはないので、アルゴリズムは大好きです。

[Libra]

自分はdoubleの方が早いと思っていました。
自分も>http://www.pro.or.jp/~fuji/mybooks/cdiag/cdiag.4.4.html
ここで、doubleの方が早いと見て「ふ～ん」と思ってました。


それで実際に計測してみたのですが・・・・

> Dixqさん
速度の計測方法なのですが、

#include <stdio.h>
#include <time.h>

int main(void){
    int i;
    float sum;
    int timer;
    
    printf("size\n");
    printf("float %d\n",sizeof(float));
    printf("int %d\n",sizeof(int));
    printf("double %d\n",sizeof(double));
    timer = clock();
    for(i=0;i<1000000000;i++){
            sum += 1.0 ;
    }
    printf("%dms\n",clock()-timer);

    return 0;
}

この場合のsumでは、殆ど差は現れませんでした。

自分のパソコン(WinXP)では、両者とも3000msでした。

ここまでは、管理人さんが提示した結果と同じなのです。

しかし、以下のソースで計測した場合、floatの方が早い速度が出ました。

#include <stdio.h>
#include <time.h>
int main(void){
    int i;
    float sum1=3.5;
    float sum2=23.2;
    float sum3;
    int timer;
    
    printf("size\n");
    printf("float %d\n",sizeof(float));
    printf("int %d\n",sizeof(int));
    printf("double %d\n",sizeof(double));
    timer = clock();
    for(i=0;i<1000000000;i++){
            sum3 = sum1 / sum2 ;
    }
    printf("%dms\n",clock()-timer);

    return 0;
}

sumの型をfloatとdoubleに変えて計測したところ、
floatが7437ms、doubleが12719msでした。
10回程計測しましたが、大体floatが7秒、doubleが12秒でした。

5秒の差はかなり大きいのではないでしょうか。

「+=」で演算すると、ほとんど差が出ないのに、除算だと結構差が出ます。
また、演算を行わず、ループを同じ回数まわすだけの時は、300ms程度でした。(計測回数10回)
よって、ループによる時間の影響はほとんどないと考えられます。


実際計測して、今まで覚えてたものと違ってびっくりしてます。
この計測方法でもdoubleの方が場合によって早くなったりするのでしょうか・・・？

[たかぎ]

> 特にOSやCPUの規格を意識していないです。
> 自身で一番多い開発環境がWinXPでのVC6～2008で、それ以外の環境でどうこうまでは考えていません。
> WinOS、VC使いが、Windows上でだけ動かすものを作るために考えた結果という認識でお願いします。

なるほど。
まあ、Windowsといっても、例えばCPUがARMのモバイル環境もあるわけで、そういった場合は当然事情が異なりますね。

> 重要なのはそのような常識は変わりうる、という事を意識しておくことと思い、

これはそのとおりですね。
ひとついえることは、あの書籍は標準化以前のCを対象にしているということです。
その場合、floatであってもdoubleに変換してから演算するのは言語仕様でしたので、あのような記述になっています。
ですので、単純に常識が時代とともに変化するというのとは、ちょっと違います。

> 最終段階で必要に迫られたとき以外は、そのような最適化はしません。
> 当然、その時は実測しながらです。

これは状況次第かもしれません。
最終的な最適化で済むのはアプリケーションの場合だけですので、ライブラリなどでは最適化のタイミングも変わります。
あと、環境によっては、floatとdoubleを混在させると遅い場合もあるので、実際に最適化するかどうかはともかく、事前に知っておくことは悪くないと思います。

[たいちう]

Libraさん
> 実際計測して、今まで覚えてたものと違ってびっくりしてます。

コンパイラやコンパイルオプションを教えてください。
今、PCに負荷をかけていて測定できませんので、
私も後ほど追試したいと思います。

ソースコードを見る限りだと、最適化がどこまで効いているかですね。
sumもsum3も参照されないので、コンパイラが十分賢ければ、
ループ自体がなくなるはずです。

測定結果に最適化の程度が影響を与えている可能性がありますが、
もしも自分の使うコンパイラがfloatの最適化の方が
得意だという結論だとしても、意義のある測定結果ですね。


たかぎさん
> 最終的な最適化で済むのはアプリケーションの場合だけですので、
> ライブラリなどでは最適化のタイミングも変わります。

なるほど、作成時に使用状況が分からない場合もありますね。
一般のアプリケーションも、客先等でどのような使われ方を
されるか分かりませんが、ライブラリよりはまだ予想しやすいですね。

[たかぎ]

> Libraさん

> sumの型をfloatとdoubleに変えて計測したところ、
> floatが7437ms、doubleが12719msでした。
> 10回程計測しましたが、大体floatが7秒、doubleが12秒でした。

Intel Macでも似たような結果になりました。
# 最適化すると、ループ自体がなくなってしまうのですが...

時間のあるときに、コンパイル結果を見て解析してみたいと思います。

[シエル]

初めはfloatのほうがdoubleより高速だと思ってましたが、
何かの本でfloatはdoubleに変換されてから処理されるというような事が
書いてあったので、それからはdoubleの方が高速だと勝手に思ってます。

CPU等の話になるとついていけない。。。
自分の知識不足を思い知らされる。。。

[たかぎ]

> シエルさん

> 何かの本でfloatはdoubleに変換されてから処理されるというような事が
> 書いてあったので、それからはdoubleの方が高速だと勝手に思ってます。

たぶん↓ですね。
http://www.pro.or.jp/~fuji/mybooks/cdiag/cdiag.4.4.html

[fr]

ちょっと関係ない話かもしれませんがDirectXではfloat型に最適化されていて速いみたいなことを聞きました

[たかぎ]

> frさん

> ちょっと関係ない話かもしれませんがDirectXではfloat型に最適化されていて速いみたいなことを聞きました

DirectX内部ではそうでも、それ以外のところでは影響を受けないのでは？

[山崎]

うっ、floatの方が速いのではないのですかっ！？

今までずっと、あまり高い精度が必要でない少数はfloatにするように心がけてました（汗）。
まぁ、速さよりもメモリの節約が主な目的でfloatを積極的に使っていました。
サイズが小さいからdoubleよりはfloatの方が処理が遅いことはまぁ無いだろうと
漠然を思っていましたが、必ずしもそうではないのですね…。

今は潤沢にメモリがある時代なんで、メモリ節約よりも処理速度向上を選んだほうが
いいかもしれないですね…。特にゲーム作りなどにおきましては。

しかし議論を拝見していますと、floatもdoubleも処理速度に大きな違いは無かったり、
floatの方が速い、という意見もあるようですね。

結局のところ、小数を全てdoubleで扱ったからといって、
多くの場合で効果的な高速化ができる、というわけではないのでしょうか。

[たかぎ]

> 山崎さん

> うっ、floatの方が速いのではないのですかっ！？

そうとはいっていません。
ご意見をうかがっているだけです。

> サイズが小さいからdoubleよりはfloatの方が処理が遅いことはまぁ無いだろうと
> 漠然を思っていましたが、必ずしもそうではないのですね…。

では、floatの方が速いとお考えなのですね。

> 今は潤沢にメモリがある時代なんで、メモリ節約よりも処理速度向上を選んだほうが
> いいかもしれないですね…。特にゲーム作りなどにおきましては。

潤沢にメモリがあるのは特定のプラットフォームだけです。

[Dixq (管理人)]

仕事や趣味でマイコンとか組み込みとかされてる人にはまだまだメモリは貴重な存在ですよね

そういう話で言えばうちの製品ではハードウェアで浮動小数が計算出来ないのでdoubleの方がむちゃくちゃ遅いです。とにかく浮動小数を使わずに実装しようと試みてます。

[たかぎ]

> 仕事や趣味でマイコンとか組み込みとかされてる人にはまだまだメモリは貴重な存在ですよね

そうですね。
メモリサイズの制約が大きい環境では、メモリの使用量を気にせずに設計やコーディングを行うというのは、程度にもよりますが、時期尚早な不最適化になってしまいます、

[たかぎ]

メモリサイズについて、もう一言。

実行速度に関しては、ボトルネックなる部分というのはごく一部です。
けれども、サイズを肥大化に関しては、そのコードやデータの利用頻度がどんなに低くても、存在するだけで平等に責任があります。
だからこそ、明らかにfloatの精度で済むところをdoubleにするのは、オブジェクトの数が十分少ない場合を除けば、時期尚早な不最適化になりますね。

[たかぎ]

Libraさんのコードを少し修正して乗算で試してみると、今度は逆にdoubleのほうがfloatより40%ぐらい速くなっています。
まだざっくりとしか調べていないのと、IA-32は必ずしも得意ではないのとで、原因がはっきりわかっていません。
mulssとmulsdの各命令を比べれば、データシート上はmulss（つまりfloatのほう）がレイテンシもスループットも同じかよいので、なぜこのような結果になるのかわかりません。

[softya]

>mulssとmulsdの各命令を比べれば、データシート上はmulss（つまりfloatのほう）がレイテンシもスループットも同じかよいので、なぜこのような結果になるのかわかりません。

パイプライン上ので動作が違うのかもしれません。

ＣＰＵやＦＰＵ搭載・性能やコンパイラなどによって違うので、実測値や実装コードを確認するようにしています。
少なくともＦＰＵ非搭載ならコンパイラ無関係にfloatの方が早いと思っています（実測しますが）。最近のx86系だと浮動小数点で速度的にシビアなコードを書いていないのですが、doubleの方が早い印象があります。

と言う事で実測してみました。CPUが変われば結果も違うと思います。
OS:Windows7(64bit)
開発環境:VisualStudio2005Standard(x86でReleaseビルド)
CPU:AMD Athlon II X4 630 Processor 2.8GHz

---------------------------------------------
ループ100000000回 テスト10回　平均
---------------------------------------------

-- 加算 -------------------------------------------
float ave(加算)：550ms
double ave(加算)：236ms
int ave(加算)：73ms
long long int ave(加算)：264ms
-- 減算 -------------------------------------------
float ave(減算)：548ms
double ave(減算)：229ms
int ave(減算)：73ms
long long int ave(減算)：262ms
-- 除算 -------------------------------------------
float ave(除算)：1137ms
double ave(除算)：842ms
int ave(除算)：959ms
long long int ave(除算)：2084ms
-- 乗算 -------------------------------------------
float ave(乗算)：541ms
double ave(乗算)：237ms
int ave(乗算)：110ms
long long int ave(乗算)：528ms
---------------------------------------------

[softya]

cinしているデータは添付します。

下記は、計測のコードです。
Libraさんのコードをベースに最適化がなるべく掛からない様に無理やり工夫してあります。
C++とC言語の書き方の混在はご容赦ください。

#include <iostream>
using namespace std;
#include <stdio.h>
#include <time.h>


enum {
MODE_ADD,
MODE_SUB,
MODE_DIV,
MODE_MUL,

MODE_MAX,
};

char *mode_type[/url] = {
"加算",
"減算",
"除算",
"乗算",
};

template<class T> int CalcTmp(char*name,T &value,int loop,int mode)
{
int timer;
T val2[2];

cin >> val2[0] >> val2[1];
cout << "計算値:" << val2[0] << ":" << val2[1] << " ";

timer = clock();
switch(mode) {
case MODE_ADD:
value = (T)0;
for(int i=0;i<loop;i++){
value += val2[i&1];
}
break;

case MODE_SUB:
value = (T)0;
for(int i=0;i<loop;i++){
value -= val2[i&1];
}
break;

case MODE_DIV:
value = (T)1;
for(int i=0;i<loop;i++){
value /= val2[i&1];
}
break;

case MODE_MUL:
value = (T)1;
for(int i=0;i<loop;i++){
value *= val2[i&1];
}
break;
}

int times = (clock()-timer) * 1000 / CLOCKS_PER_SEC;
cout << "結果:" << value;
printf(" %s(%s) (%d)loops time:%dms\n",name,mode_type[mode],loop,times);

return times;
}

int main(void)
{
int TestCount;
int LoopCount;

int avetime[4][MODE_MAX] = {{0}};
float fval;
double dval;
int ival;
long long int lval;

cin >> TestCount;
cin >> LoopCount;

printf("テスト回数 %d回　ループ回数 %d回\n",TestCount,LoopCount);
printf("-----------------------------\n");
printf("float size: %dbyte\n",sizeof(fval));
printf("double size: %dbyte\n",sizeof(dval));
printf("int size: %dbyte\n",sizeof(ival));
printf("long long int size: %dbyte\n",sizeof(lval));
printf("-----------------------------\n");
printf("\n");

for( int test=0 ; test<TestCount ; test++ ) {
printf( "----- test No.%d ----------------------------------------\n",test+1);
for( int mode=MODE_ADD ; mode<=MODE_MUL ; mode++ ) {
printf( "-- %s -------------------------------------------\n", mode_type[mode] );
avetime[0][mode] += CalcTmp("float",fval,LoopCount,mode);
avetime[1][mode] += CalcTmp("double",dval,LoopCount,mode);
avetime[2][mode] += CalcTmp("int",ival,LoopCount,mode);
avetime[3][mode] += CalcTmp("long long int",lval,LoopCount,mode);
}
}

printf( "\n" );
printf( "\n" );
printf( "---------------------------------------------\n" );
printf( " ループ%d回 テスト%d回　平均\n",LoopCount,TestCount );
printf( "---------------------------------------------\n" );
printf( "\n" );
for( int mode=MODE_ADD ; mode<=MODE_MUL ; mode++ ) {
printf( "-- %s -------------------------------------------\n", mode_type[mode] );
printf( "float ave(%s)：%dms\n", mode_type[mode], avetime[0][mode] / TestCount );
printf( "double ave(%s)：%dms\n", mode_type[mode], avetime[1][mode] / TestCount );
printf( "int ave(%s)：%dms\n", mode_type[mode], avetime[2][mode] / TestCount );
printf( "long long int ave(%s)：%dms\n", mode_type[mode], avetime[3][mode] / TestCount );
}
printf( "---------------------------------------------\n" );

return 0;
}

[Justy]

＞今度は逆にdoubleのほうがfloatより40%ぐらい速くなっています

　普通の四則演算の場合で、Visual C++だとコンパイルオプションによって
変わってきそうです。


/fp (浮動小数点の動作の指定) (C++)
http://msdn.microsoft.com/ja-jp/library ... S.80).aspx

・　/fp:fast
　floatも doubleも連続して演算するのでほとんど差はないと思います。

・　/fp:precise
　float型の演算をするとき１回計算する度にメモリにストア、再利用するときに
メモリからロードするコードを吐くのでその分遅くなりそうです。

・　/fp:strict
　floatと doubleどちらもメモリにロード・ストアするので /fp:fastより遅いですが、
それほど大きな差はないと思います。


　あと /archの方も影響があるかもしれません。

/arch (最小限の CPU アーキテクチャ)
http://msdn.microsoft.com/ja-jp/library/7t5yh4fd.aspx

[softya]

みなさんも興味があると思うので、ついでに64bitモードです。
OS:Windows7(64bit)
開発環境:VisualStudio2005Standard(x64でReleaseビルド)
CPU:AMD Athlon II X4 630 Processor 2.8GHz

恐ろしいほどx86と違う結果に。
予想通り long long intが速くなりますね。
あと、doubleとfloatの差が誤差範囲の差しか無くなります(除算除く)。
---------------------------------------------
ループ100000000回 テスト10回　平均
---------------------------------------------

-- 加算 -------------------------------------------
float ave(加算)：148ms
double ave(加算)：147ms
int ave(加算)：110ms
long long int ave(加算)：111ms
-- 減算 -------------------------------------------
float ave(減算)：147ms
double ave(減算)：151ms
int ave(減算)：81ms
long long int ave(減算)：76ms
-- 除算 -------------------------------------------
float ave(除算)：588ms
double ave(除算)：741ms
int ave(除算)：999ms
long long int ave(除算)：998ms
-- 乗算 -------------------------------------------
float ave(乗算)：146ms
double ave(乗算)：164ms
int ave(乗算)：151ms
long long int ave(乗算)：147ms
---------------------------------------------

[たいちう]

softyaさんのテスト結果についてですが、
処理時間がdouble < floatなのは予想通りですが、
除算についてわずかといえどdouble < intなのは意外でした。

ちなみに、sizeof(int) = sizeof(double) = 8ですよね？

[softya]

>ちなみに、 sizeof(int) = sizeof(double) = 8ですよね？

いえ、x64モードでコンパイルしてもintは４バイトです。
たしか、マイクロソフトのサイトの何処かに書いてあったと思います。

-----------------------------
float size: 4byte
double size: 8byte
int size: 4byte
long long int size: 8byte
-----------------------------

アセンブルコードも添付します。
コンパイルオプションは特にいじっていません。

[たかぎ]

みなさん、情報ありがとうございます。

doubleの方が圧倒的に速いのはAMDの特徴でしょうかね。
私はまだMac上のGCC（32bitと64bit）でしか試していないのですが、CPUの種類によってかなりバラつくことは確かなようですね。

[たかぎ]

softyaさんが計測に使ったコードですが、32bit版のコンパイル結果を見ると、intの場合はループ2周分を開いているのに対して、floatやdoubleの場合はループ4周分を開いているように見えます。
ざっとしか見ていないので見間違いや勘違いがあるかもしれませんが、ちょっと計測方法に公正さを欠くかもしれません。

[softya]

>softyaさんが計測に使ったコードですが、32bit版のコンパイル結果を見ると、intの場合はループ2周分を開いているのに対して、floatやdoubleの場合はループ4周分を開いているように見えます。

あっ、そう見えますね。
うーん。まだ甘かったか。すごいぞ最適化。
もう少し、最適化と格闘してみます。

[たかぎ]

まだ若干議論中の内容も残っていますが、過去ログに落ちてしまいそうなのでいったん解決にしておきます。
必要に応じて、改めて新スレッドを立てます（誰か立ててくださってもいいです）。