「クリーン」コード、ひどいパフォーマンス (2023)
"Clean" Code, Horrible Performance (2023) (computerenhance.com)
要約
この記事は、多くのプログラミングにおける「クリーンコード」のベストプラクティス、特にポリモーフィズムの使用が、スイッチ文などの代替手段と比較して著しくパフォーマンスを低下させる可能性があると論じています。著者は、コードの構造をオブジェクト指向にし、関数を小さく保つといった一般的な推奨事項が、実際の実行速度に悪影響を与える場合があることを、具体的なコード例とパフォーマンス測定結果を挙げて示しています。
全文翻訳
"クリーン"コードは、ひどいパフォーマンスを生む
これは「パフォーマンスを意識したプログラミング」シリーズの無料ボーナスビデオです。このビデオでは、「クリーンコード」のガイドラインに従うことの実際のパフォーマンスコストを示します。コースの詳細については、AboutページまたはTable of Contentsをご覧ください。
以下は、ビデオの軽微な編集を加えたトランスクリプトです。
プログラマー、特に初心者によく繰り返されるアドバイスの1つは、「クリーン」なコードを書くべきだということです。この「クリーン」という言葉には、コードを「クリーン」にするために何をすべきかを指示する長いルールのリストが伴います。
これらのルールの大部分は、実際に書いたコードの実行時間には影響しません。これらの種類のルールは客観的に評価できず、その時点ではかなり恣意的であるため、必ずしも評価する必要はありません。しかし、「クリーン」コードのいくつかのルール、特に最も強調されるものの中には、実行時のコードの動作に影響するため、客観的に測定できるものがあります。
「クリーン」コードの概要を見て、コードの構造に実際に影響するルールを抜き出すと、次のようになります。
- "if/else" および "switch" よりもポリモーフィズムを優先する
- コードは、それが操作しているオブジェクトの内部を知るべきではない
- 関数は小さくすべきである
- 関数は1つのことだけをすべきである
- "DRY" - Don't Repeat Yourself (繰り返しを避ける)
これらのルールは、コードが「クリーン」であるために、特定のコード片がどのように作成されるべきかについて、かなり具体的に述べています。ここで私が問いたいのは、これらのルールに従ってコードを作成した場合、そのパフォーマンスはどうなるかということです。
私が「クリーン」コード実装の最も有利なケースを構築するために、私は「クリーンコード」の文献に含まれる既存のサンプルコードを使用しました。これにより、私は何も作り出しておらず、単に「クリーン」コードの提唱者のルールを、それらを説明するために彼らが提供するサンプルコードで評価しているだけです。
「クリーン」コードの例を見ると、しばしばこのような例が見られます。
/* ========================================================================
LISTING 22
======================================================================== */
class shape_base
{
public:
shape_base() {}
virtual f32 Area() = 0;
};
class square : public shape_base
{
public:
square(f32 SideInit) : Side(SideInit) {}
virtual f32 Area() {return Side*Side;}
private:
f32 Side;
};
class rectangle : public shape_base
{
public:
rectangle(f32 WidthInit, f32 HeightInit) : Width(WidthInit), Height(HeightInit) {}
virtual f32 Area() {return Width*Height;}
private:
f32 Width, Height;
};
class triangle : public shape_base
{
public:
triangle(f32 BaseInit, f32 HeightInit) : Base(BaseInit), Height(HeightInit) {}
virtual f32 Area() {return 0.5f*Base*Height;}
private:
f32 Base, Height;
};
class circle : public shape_base
{
public:
circle(f32 RadiusInit) : Radius(RadiusInit) {}
virtual f32 Area() {return Pi32*Radius*Radius;}
private:
f32 Radius;
};
これは、円、三角形、長方形、正方形といったいくつかの特定の形状から派生した形状の基底クラスです。そして、面積を計算する仮想関数があります。
ルールが要求するように、私たちはポリモーフィズムを優先しています。私たちの関数は1つのことだけを行います。それらは小さく、そのすべての良い点があります。その結果、各派生クラスが自身の面積を計算する方法を知っており、その面積を計算するために必要なデータを格納している、「クリーン」なクラス階層が得られます。
この階層を使用して何かを行う場合、例えば、渡された一連の形状の合計面積を見つける場合、次のようなものになると予想されます。
/* ========================================================================
LISTING 23
======================================================================== */
f32 TotalAreaVTBL(u32 ShapeCount, shape_base **Shapes)
{
f32 Accum = 0.0f;
for(u32 ShapeIndex = 0; ShapeIndex < ShapeCount; ++ShapeIndex)
{
Accum += Shapes[ShapeIndex]->Area();
}
return Accum;
}
イテレータを使用していないことに気づくかもしれませんが、それはルールにイテレータを使用する必要があるという示唆がなかったためです。そのため、「クリーン」コードに有利な解釈を与え、コンパイラを混乱させてパフォーマンスを低下させる可能性のある抽象化されたイテレータを追加しないことにしました。
また、このループがポインタの配列上で行われていることにも気づくかもしれません。これはクラス階層を使用することの直接的な結果です。これらの形状のそれぞれがメモリ内でどれくらいの大きさになるかは、私たちにはわかりません。そのため、各形状のデータサイズを取得するための別の仮想関数呼び出しを追加し、それらを通過するために何らかの可変スキップ手順を使用しない限り、各形状が実際にどこから始まるかを見つけるためにポインタが必要になります。
これは累積であるため、ループキャリード依存関係があり、ループが遅くなる可能性があります。累積は任意に並べ替えることができるため、念のため手動でアンロールしたバージョンも作成しました。
/* ========================================================================
LISTING 24
======================================================================== */
f32 TotalAreaVTBL4(u32 ShapeCount, shape_base **Shapes)
{
f32 Accum0 = 0.0f;
f32 Accum1 = 0.0f;
f32 Accum2 = 0.0f;
f32 Accum3 = 0.0f;
u32 Count = ShapeCount/4;
while(Count--)
{
Accum0 += Shapes[0]->Area();
Accum1 += Shapes[1]->Area();
Accum2 += Shapes[2]->Area();
Accum3 += Shapes[3]->Area();
Shapes += 4;
}
f32 Result = (Accum0 + Accum1 + Accum2 + Accum3);
return Result;
}
これらの2つのルーチンを単純なテストハーネスで実行すると、その操作を実行するために必要な形状あたりの合計サイクル数を大まかに測定できます。
[画像: 2つのルーチン(TotalAreaVTBLとTotalAreaVTBL4)のパフォーマンス測定結果を示すグラフ。コールド状態とホット状態でのサイクル数を示している。]
ハーネスはコードを2つの異なる方法で計測します。最初の方法は、コードを1回だけ実行して、任意の「コールド」状態(データはL3にあるはずだが、L2とL1はフラッシュされており、分岐予測器がループで「練習」していない)で何が起こるかを示します。2番目の方法は、コードを何度も繰り返し実行して、キャッシュと分岐予測器がループにとって最も有利な方法で動作している場合に何が起こるかを確認します。これらのいずれも厳密な測定ではないことに注意してください。なぜなら、これから見ていく違いは非常に大きいため、真剣な分析ツールを取り出す必要がないからです。
結果からわかることは、2つのルーチン間に大きな違いはないということです。形状の「クリーン」コード面積計算を実行するには、約35サイクルかかります。運が良ければ、時には34サイクル近くまで下がることもあります。
したがって、35サイクルがすべてのルールに従った場合に期待できる値です。もし代わりに、最初のルールを1つだけ違反したらどうなるでしょうか?ここでポリモーフィズムを使用する代わりに、switch文を使用したらどうなるでしょうか?[1]
ここでは、クラス階層(したがって、実行時にはvtable)を使用する代わりに、enumと、すべてを1つの構造体にフラット化する形状タイプを使用して、まったく同じコードを記述しました。
/* ========================================================================
LISTING 25
======================================================================== */
enum shape_type : u32
{
Shape_Square,
Shape_Rectangle,
Shape_Triangle,
Shape_Circle,
Shape_Count,
};
struct shape_union
{
shape_type Type;
f32 Width;
f32 Height;
};
f32 GetAreaSwitch(shape_union Shape)
{
f32 Result = 0.0f;
switch(Shape.Type)
{
case Shape_Square: {Result = Shape.Width*Shape.Width;} break;
case Shape_Rectangle: {Result = Shape.Width*Shape.Height;} break;
case Shape_Triangle: {Result = 0.5f*Shape.Width*Shape.Height;} break;
case Shape_Circle: {Result = Pi32*Shape.Width*Shape.Width;} break;
case Shape_Count: {} break;
}
return Result;
}
これは、「クリーン」コードの講義では絶対にやってはいけないと言われるであろうswitch文を使用した、このコードの「昔ながらの」書き方です。
特定の形状バリアントのデータ型がなくなったため、型が質問のいずれかの値(たとえば「高さ」)を持っていない場合、単に使用しないことに注意してください。
今や、仮想関数呼び出しから面積を取得する代わりに、この構造体のユーザーはswitch文を持つ関数からそれを取得します。コードはより簡潔ですが、基本的に同じです。switch文の各ケースは、クラス階層の対応する仮想関数と同じコードです。
合計ループ自体については、それらが「クリーン」バージョンとほぼ同じであることがわかります。
/* ========================================================================
LISTING 26
======================================================================== */
f32 TotalAreaSwitch(u32 ShapeCount, shape_union *Shapes)
{
f32 Accum = 0.0f;
for(u32 ShapeIndex = 0; ShapeIndex < ShapeCount; ++ShapeIndex)
{
Accum += GetAreaSwitch(Shapes[ShapeIndex]);
}
return Accum;
}
f32 TotalAreaSwitch4(u32 ShapeCount, shape_union *Shapes)
{
f32 Accum0 = 0.0f;
f32 Accum1 = 0.0f;
f32 Accum2 = 0.0f;
f32 Accum3 = 0.0f;
ShapeCount /= 4;
while(ShapeCount--)
{
Accum0 += GetAreaSwitch(Shapes[0]);
Accum1 += GetAreaSwitch(Shapes[1]);
Accum2 += GetAreaSwitch(Shapes[2]);
Accum3 += GetAreaSwitch(Shapes[3]);
Shapes += 4;
}
f32 Result = (Accum0 + Accum1 + Accum2 + Accum3);
return Result;
}
唯一の違いは、面積を取得するためにメンバ関数を呼び出す代わりに、通常の関数を呼び出すことです。それだけです。
しかし、クラス階層と比較してフラット化された構造を使用することの即時の利点をすでに目にすることができます。形状は配列に入れることができ、ポインタは不要です。すべての形状を同じサイズにしたため、間接参照はありません。
さらに、コンパイラはループで何をしているかを正確に把握できるという追加の利点があります。なぜなら、コンパイラはGetAreaSwitch関数を見て、コードパス全体を見ることができるからです。実行時にのみ知られている仮想化された面積関数で何でも起こりうることを想定する必要はありません。
では、これらの利点により、コンパイラは何をしてくれるのでしょうか?これら4つすべてを一緒に実行すると、結果はどうなるでしょうか。
[画像: 4つのルーチン(TotalAreaVTBL、TotalAreaVTBL4、TotalAreaSwitch、TotalAreaSwitch4)のパフォーマンス測定結果を示すグラフ。]
結果を見ると、非常に注目すべきことがあります。その1つの変更、つまり「クリーン」コードの方法ではなく、昔ながらの方法でコードを書いただけで、即座に1.5倍のパフォーマンス向上が得られました。これは、C++のポリモーフィズムを使用するために必要な余分なものを削除しただけで得られる、無料の1.5倍です。
したがって、クリーンコードの最初のルール(中心的な原則の1つ)を違反することで、形状あたりの35サイクルから24サイクルに低下させることができ、そのルールに従ったコードは従わないコードよりも1.5倍遅いということになります。ハードウェアの観点から見ると、iPhone 14 Pro MaxをiPhone 11 Pro Maxにダウングレードするようなものです。「クリーン」コードの原則に従うことで、3〜4年分のハードウェアの進化が消去されたことになります。
しかし、私たちはまだ始まったばかりです。
さらに多くのルールを破ったらどうなるでしょうか?「内部知識を持たない」という2番目のルールも破ったらどうなるでしょうか?関数が、それらが実際に操作しているものについての知識を使用して、それらをより効率的にすることができるとしたらどうなるでしょうか?
Get Area Switch文をもう一度見ると、面積計算が類似していることがわかります。
case Shape_Square: {Result = Shape.Width*Shape.Width;} break;
case Shape_Rectangle: {Result = Shape.Width*Shape.Height;} break;
case Shape_Triangle: {Result = 0.5f*Shape.Width*Shape.Height;} break;
case Shape_Circle: {Result = Pi32*Shape.Width*Shape.Width;} break;
これらはすべて、幅×高さ、または幅×幅のようなことを行っており、オプションでπのような係数が付きます。そして、三角形の場合は半分、円の場合はパイのようなもので乗算されます。
これは、実際、「クリーン」コードの提唱者とは異なり、私がswitch文を素晴らしいと思う理由の1つです!これらは、この種のパターンを非常に簡単に見えるようにします。コードがタイプではなく操作によって整理されている場合、共通のパターンを観察して引き出すことは簡単です。対照的に、クラスバージョンに戻って見ると、おそらくこの種のパターンに気づくことはないでしょう。なぜなら、ボイラープレートが多く邪魔になるだけでなく、「クリーン」コードの提唱者は各クラスを別のファイルに置くことを推奨しており、それにより、このようなことに気づく可能性がさらに低くなるからです。
したがって、アーキテクチャ的には私は一般的にクラス階層に反対しますが、それは本質的な問題ではありません。今私が本当に言いたい唯一の点は、パターンを抽出できることに気づくことで、このswitch文をかなり簡略化できるということです。
そして覚えておいてください:これは私が選んだ例ではありません!これは、クリーンコードの提唱者自身が説明目的で使用する例です。したがって、パターンを抽出できる例を意図的に選んだわけではありません。それは非常に可能性が高いことです。なぜなら、類似のタイプのほとんどのものは類似のアルゴリズム構造を持っているため、予想どおり、ここで発生するからです。
このパターンを利用するために、各タイプに必要な係数を示す単純なテーブルを導入できます。次に、円や正方形のような単一パラメータのタイプで幅を高さに複製すると、劇的に単純化された面積関数を作成できます。
/* ========================================================================
LISTING 27
======================================================================== */
f32 const CTable[Shape_Count] = {1.0f, 1.0f, 0.5f, Pi32};
f32 GetAreaUnion(shape_union Shape)
{
f32 Result = CTable[Shape.Type]*Shape.Width*Shape.Height;
return Result;
}
このバージョンの2つの合計ループはまったく同じです。変更する必要はありません。単にGetAreaSwitchの代わりにGetAreaUnionを呼び出すだけで、それ以外は同一です。
この新しいバージョンを以前のループと比較して実行するとどうなるか見てみましょう。
[画像: 4つのルーチン(TotalAreaVTBL、TotalAreaVTBL4、TotalAreaSwitch、TotalAreaSwitch4、GetAreaUnion)のパフォーマンス測定結果を示すグラフ。]
ここからわかることは、実際のタイプに関する知識を活用すること、つまり、タイプベースの考え方から関数ベースの考え方に切り替えることで、大規模な速度向上が得られるということです。スイッチ文バージョンが単に1.5倍速かったものから、テーブル駆動バージョンでは、まったく同じ問題で10倍以上速くなりました。
これを行うために、テーブルルックアップと単一行のコード以外は何も使用しませんでした!それは単に速いだけでなく、意味論的にもはるかに単純です。トークンが少なく、操作が少なく、コード行数も少なくなります。
したがって、データモデルと望ましい操作を融合させることで、操作が内部を知らないことを要求するのではなく、形状あたりの3.0〜3.5サイクルの範囲まで到達しました。これは、「クリーン」コードバージョンと比較して10倍の速度向上です。
10倍という速度向上は非常に大きいため、iPhoneの例でさえ表現できません。iPhoneのベンチマークはそこまで遡れないからです。iPhone 6まで遡っても、これはiPhone 14 Pro Maxよりも約3倍遅いだけです。したがって、この違いを説明するために電話を使うことさえできません。
シングルスレッドのデスクトップパフォーマンスを見ると、10倍の速度向上は、今日の平均CPUマークから2010年の平均CPUマークまで遡るようなものです!「クリーンコード」の概念の最初の2つのルールは、それらだけで12年のハードウェア進化を無効にします。
しかし、これが衝撃的であっても、このテストは非常に単純な操作しか行っていません。「関数は小さくすべき」や「関数は1つのことだけをすべき」といったルールは、最初の場所で非常に単純なことを1つしか行うことがないため、あまり使用していません。問題に別の側面を追加して、これらのルールをより直接的に従うことができるようにしたらどうなるでしょうか?
ここでは、以前と同じ階層を記述しましたが、今回は形状の角の数を伝える別の仮想関数を1つ追加しました。
/* ========================================================================
LISTING 32
======================================================================== */
class shape_base
{
public:
shape_base() {}
virtual f32 Area() = 0;
virtual u32 CornerCount() = 0;
};
class square : public shape_base
{
public:
square(f32 SideInit) : Side(SideInit) {}
virtual f32 Area() {return Side*Side;}
virtual u32 CornerCount() {return 4;}
private:
f32 Side;
};
class rectangle : public shape_base
{
public:
rectangle(f32 WidthInit, f32 HeightInit) : Width(WidthInit), Height(HeightInit) {}
virtual f32 Area() {return Width*Height;}
virtual u32 CornerCount() {return 4;}
private:
f32 Width, Height;
};
class triangle : public shape_base
{
public:
triangle(f32 BaseInit, f32 HeightInit) : Base(BaseInit), Height(HeightInit) {}
virtual f32 Area() {return 0.5f*Base*Height;}
virtual u32 CornerCount() {return 3;}
private:
f32 Base, Height;
};
class circle : public shape_base
{
public:
circle(f32 RadiusInit) : Radius(RadiusInit) {}
virtual f32 Area() {return Pi32*Radius*Radius;}
virtual u32 CornerCount() {return 0;}
private:
f32 Radius;
};
長方形は4つの角、三角形は3つ、円は0個などです。次に、問題の定義を、一連の形状の面積の合計を計算することから、角数で重み付けされた面積の合計を計算することに変更します。これは、角の数に1を足したものの逆数として定義します。
面積の合計と同様に、これに理由はありません。単に例の中で作業しているだけです。私が考えられる最も単純なものを追加し、それに対して非常に基本的な数学を行いました。
「クリーン」な合計ループを更新するには、必要な数学と追加の仮想関数呼び出しを追加します。
f32 CornerAreaVTBL(u32 ShapeCount, shape_base **Shapes)
{
f32 Accum = 0.0f;
for(u32 ShapeIndex = 0; ShapeIndex < ShapeCount; ++ShapeIndex)
{
Accum += (1.0f / (1.0f + (f32)Shapes[ShapeIndex]->CornerCount())) * Shapes[ShapeIndex]->Area();
}
return Accum;
}
f32 CornerAreaVTBL4(u32 ShapeCount, shape_base **Shapes)
{
f32 Accum0 = 0.0f;
f32 Accum1 = 0.0f;
f32 Accum2 = 0.0f;
f32 Accum3 = 0.0f;
u32 Count = ShapeCount/4;
while(Count--)
{
Accum0 += (1.0f / (1.0f + (f32)Shapes[0]->CornerCount())) * Shapes[0]->Area();
Accum1 += (1.0f / (1.0f + (f32)Shapes[1]->CornerCount())) * Shapes[1]->Area();
Accum2 += (1.0f / (1.0f + (f32)Shapes[2]->CornerCount())) * Shapes[2]->Area();
Accum3 += (1.0f / (1.0f + (f32)Shapes[3]->CornerCount())) * Shapes[3]->Area();
Shapes += 4;
}
f32 Result = (Accum0 + Accum1 + Accum2 + Accum3);
return Result;
}
これをさらに別の関数に抽出し、さらに別の間接レイヤーを追加することもできますが、ここでも「クリーン」コードに有利な解釈を与え、そのままにしておきます。
switch文バージョンを更新するには、基本的に同じ変更を行います。まず、角の数についても別のswitch文を追加し、階層バージョンとまったく同じケースをミラーリングします。
/* ========================================================================
LISTING 34
======================================================================== */
u32 GetCornerCountSwitch(shape_type Type)
{
u32 Result = 0;
switch(Type)
{
case Shape_Square: {Result = 4;} break;
case Shape_Rectangle: {Result = 4;} break;
case Shape_Triangle: {Result = 3;} break;
case Shape_Circle: {Result = 0;} break;
case Shape_Count: {} break;
}
return Result;
}
次に、階層バージョンとまったく同じものを計算します。
/* ========================================================================
LISTING 35
======================================================================== */
f32 CornerAreaSwitch(u32 ShapeCount, shape_union *Shapes)
{
f32 Accum = 0.0f;
for(u32 ShapeIndex = 0; ShapeIndex < ShapeCount; ++ShapeIndex)
{
Accum += (1.0f / (1.0f + (f32)GetCornerCountSwitch(Shapes[ShapeIndex].Type))) * GetAreaSwitch(Shapes[ShapeIndex]);
}
return Accum;
}
f32 CornerAreaSwitch4(u32 ShapeCount, shape_union *Shapes)
{
f32 Accum0 = 0.0f;
f32 Accum1 = 0.0f;
f32 Accum2 = 0.0f;
f32 Accum3 = 0.0f;
ShapeCount /= 4;
while(ShapeCount--)
{
Accum0 += (1.0f / (1.0f + (f32)GetCornerCountSwitch(Shapes[0].Type))) * GetAreaSwitch(Shapes[0]);
Accum1 += (1.0f / (1.0f + (f32)GetCornerCountSwitch(Shapes[1].Type))) * GetAreaSwitch(Shapes[1]);
Accum2 += (1.0f / (1.0f + (f32)GetCornerCountSwitch(Shapes[2].Type))) * GetAreaSwitch(Shapes[2]);
Accum3 += (1.0f / (1.0f + (f32)GetCornerCountSwitch(Shapes[3].Type))) * GetAreaSwitch(Shapes[3]);
Shapes += 4;
}
f32 Result = (Accum0 + Accum1 + Accum2 + Accum3);
return Result;
}
合計面積バージョンと同様に、クラス階層実装とswitch実装の間でコードはほとんど同一に見えます。唯一の違いは、仮想関数を呼び出すか、switch文を通過するかです。
テーブル駆動ケースに進むと、操作とデータを融合させることがいかに素晴らしいかがわかります!他のすべてのバージョンとは異なり、このバージョンでは、変更する必要がある唯一のことはテーブルの値です!形状に関する二次情報を取得する必要はありません。角の数と面積係数の両方をテーブルに直接溶接でき、それ以外はコードはまったく同じままです。
/* ========================================================================
LISTING 36
======================================================================== */
f32 const CTable[Shape_Count] = {1.0f / (1.0f + 4.0f), 1.0f / (1.0f + 4.0f), 0.5f / (1.0f + 3.0f), Pi32};
f32 GetCornerAreaUnion(shape_union Shape)
{
f32 Result = CTable[Shape.Type]*Shape.Width*Shape.Height;
return Result;
}
これらの「角面積」関数すべてを実行すると、2番目の形状プロパティの追加によってパフォーマンスがどのように影響されるかを見ることができます。
[画像: 4つのルーチン(CornerAreaVTBL、CornerAreaVTBL4、CornerAreaSwitch、CornerAreaSwitch4、GetCornerAreaUnion)のパフォーマンス測定結果を示すグラフ。]
ご覧のとおり、これらの結果は「クリーン」コードにとってさらに悪化しています。以前はわずか1.5倍速かったswitch文バージョンは、今やほぼ2倍速くなり、ルックアップテーブルバージョンは15倍近く速くなっています。
これは、「クリーン」コードのさらに深い問題を示しています。問題を複雑にするほど、これらのアイデアはパフォーマンスを損ないます。実際のオブジェクトに多くのプロパティを持つ「クリーン」な手法をスケーリングしようとすると、コードのどこにでもこれらの蔓延するパフォーマンスペナルティが発生します。
「クリーン」コードの方法論を使用すればするほど、コンパイラはあなたが何をしているかを把握できなくなります。すべてが個別の翻訳単位にあり、仮想関数呼び出しの後ろにあります。コンパイラがどれほど賢くても、そのようなコードではほとんど何もできません。
さらに悪いことに、そのようなコードであなたができることもあまりありません!前述したように、値をテーブルに抽出し、switch文を削除するといった単純なことは、コードベースが関数を中心に構築されていれば簡単に達成できます。代わりにタイプを中心に構築されている場合は、大幅な書き換えなしでははるかに困難、あるいは不可能かもしれません。
したがって、10倍の速度差から15倍の速度差に移行しました。これは、形状の定義に1つの新しいパラメータを追加しただけです。これは、2023年のハードウェアを2008年まで押し戻すようなものです!12年を消去する代わりに、問題の定義に1つの新しいパラメータを追加するだけで14年を消去しています。
それ自体がひどいことです。しかし、まだ最適化については言及していません!テスト目的で、ループキャリード依存関係がないことを確認した以外は、何も最適化していません!
同じ計算のわずかに最適化されたAVXバージョンに対してこれらのルーチンを実行すると、次のようになります。
[画像: 4つのルーチン(CornerAreaVTBL、CornerAreaVTBL4、CornerAreaSwitch、CornerAreaSwitch4、GetCornerAreaUnion)とAVXバージョンのパフォーマンス測定結果を示すグラフ。]
速度差は20〜25倍の範囲です。もちろん、AVX最適化コードのいずれも、「クリーン」コードの原則に似たものは一切使用していません。
これで、4つのルールが台無しになりました。5番目のルールはどうでしょうか?
正直なところ、「繰り返しを避ける」は問題ないように思えます。リストで見られたように、私たちは実際にはあまり繰り返しませんでした。おそらく、4つのアキュムレータを持つアンロールバージョンを数えたかもしれませんが、それはデモンストレーション目的のためだけでした。このようなタイミングを行わない限り、実際には両方のルーチンを持つ必要はありません。
もし「DRY」が、2つの異なるテーブルを構築して同じ係数のバージョンをエンコードするなど、より厳格な意味を持つなら、パフォーマンスを合理的にするためにそうする必要があるかもしれないので、私は時々それに反対するかもしれません。しかし、一般的に「DRY」が単に全く同じコードを2回書かないという意味であれば、それは合理的なアドバイスのように思えます。
そして最も重要なのは、合理的なパフォーマンスを得るコードを書くために、それを違反する必要はないということです。
したがって、コード構造に実際に影響を与える5つのクリーンコードの項目の中で、1つは検討する価値があり、4つは絶対に避けるべきだと私は言います。なぜなら?おそらく気づいたかもしれませんが、ソフトウェアは今日極端に遅いのです。現代のハードウェアが実際にソフトウェアが必要とすることを実行できる速度と比較して、非常に、非常に貧弱なパフォーマンスしか発揮しません。
ソフトウェアが遅い理由を尋ねると、いくつかの答えがあります。最も支配的なものは、特定の開発環境とコーディング方法論に依存します。
しかし、コンピューティング業界のあるセグメントにとっては、「なぜソフトウェアは遅いのか」という質問に対する答えは、大部分が「クリーンコード」のためです。「クリーン」コードの方法論の根底にある考え方は、ほぼすべてパフォーマンスにとってひどいものであり、それらは避けるべきです。
「クリーン」コードのルールは、コードベースをより保守しやすくすると誰かが考えたために開発されました。たとえそれが真実であったとしても、「何のために?」と尋ねる必要があります。
プログラマーの生活を少し楽にするために、10年以上のハードウェアパフォーマンスを犠牲にすることをいとわないということは、単にありえません。私たちの仕事は、与えられたハードウェアでうまく実行されるプログラムを書くことです。これらのルールがソフトウェアのパフォーマンスをこれほど悪くさせるのであれば、それらは許容できません。
コードを整理され、保守しやすく、読みやすく保つのに役立つ経験則を考案しようとすることはまだできます。それらは悪い目標ではありません!しかし、これらのルールはそうではありません。それらは、それらを実行するとコードが15倍以上遅くなるという、大きなアスタリスクを伴わない限り、言われるのをやめる必要があります。
個人的には、switch文が本質的にvtableよりもポリモーフィックでないとは言いません。それらは同じものの2つの異なる実装にすぎません。しかし、「クリーン」コードのルールはswitch文よりもポリモーフィズムを優先するように言っているので、ここでは彼らの用語を使用しています。明らかに彼らはswitch文をポリモーフィックとは考えていません。