良いC可変長配列の例[終了]

この質問はSOでかなりフリーズしたレセプションを得たので、そこで削除して代わりにここで試すことにしました。ここにも当てはまらないと思われる場合は、少なくとも私が求めている例を見つける方法の提案についてコメントを残してください...

C99 VLAを使用することで、現在の標準ヒープを使用するC ++ RAIIメカニズムなどよりも優れた例を挙げていただけますか？

私が後の例は次のとおりです：

1. ヒープを使用するよりも簡単に測定できる（おそらく10％）パフォーマンスの利点を実現します。
2. アレイ全体をまったく必要としない、適切な回避策はありません。
3. 実際には、最大サイズを固定する代わりに、動的サイズを使用するメリットがあります。
4. 通常の使用シナリオでスタックオーバーフローが発生することはほとんどありません。
5. C ++プロジェクトにC99ソースファイルを含めるためのパフォーマンスを必要とする開発者を誘惑するのに十分な強さである。

文脈上のいくつかの明確化を追加：C99の意味と、標準C ++に含まれていないように私は、VLAを意味：int array[n]どこn変数です。そして、私はそれが他の標準（C90、C ++ 11）によって提供される代替手段に勝るユースケースの例の後にいます：

int array[MAXSIZE]; // C stack array with compile time constant size
int *array = calloc(n, sizeof int); // C heap array with manual free
int *array = new int[n]; // C++ heap array with manual delete
std::unique_ptr<int[]> array(new int[n]); // C++ heap array with RAII
std::vector<int> array(n); // STL container with preallocated size

いくつかのアイデア：

• varargsを取る関数は、当然ながらアイテム数を適切なものに制限しますが、APIレベルの上限はありません。
• スタックの浪費が望ましくない再帰関数
• ヒープのオーバーヘッドが悪いであろう多くの小さな割り当てと解放。
• 多次元配列（任意のサイズの行列など）の処理。パフォーマンスが重要であり、小さな関数は多くのインライン化が期待されます。
• コメントより：ヒープ割り当てに同期オーバーヘッドがある並行アルゴリズム。

Wikipediaには、私の基準を満たさない例があります。これは、ヒープを使用することの実際的な違いは、少なくともコンテキストがないと無関係であるように見えるためです。コンテキストがなければ、アイテム数がスタックオーバーフローを引き起こす可能性が非常に高いため、これも理想的ではありません。

注：私は具体的にはサンプルコード、またはこの例を自分で実装するためにこれから利益を得るアルゴリズムの提案を求めています。

毎回同じシードで再起動する一連の乱数を生成する小さなプログラムをハッキングして、「公平」かつ「同等」であることを確認しました。それが進むにつれて、これらの値の最小値と最大値がわかります。また、一連の数値が生成されると、minおよびの平均を超える数がカウントされますmax。

非常に小さなアレイの場合、VLAが優れていることは明らかな利点を示していますstd::vector<>。

これは本当の問題ではありませんが、乱数を使用する代わりに小さなファイルから値を読み取り、同じ種類のコードを使用して他のより意味のあるカウント/最小/最大計算を実行することを簡単に想像できます。

関連する関数の「乱数の数」（x）vlaの非常に小さい値の場合、ソリューションは非常に大きな差で勝ちます。サイズが大きくなると、「勝つ」は小さくなり、十分なサイズが与えられると、ベクトルソリューションはより効率的になります。VLAに何千もの要素が含まれ始めたとき、そのバリアントはあまり研究していませんでした。彼らが何をするつもりだったのか...

そして、誰かがたくさんのテンプレートを使ってこのすべてのコードを書く方法がありcout、実行時にRDTSCとビット以上を実行せずにこれを行う方法があると私に言われると確信しています...しかし、それは本当にそうではないと思いますポイント。

この特定のバリアントを実行すると、func1（VLA）とfunc2（std :: vector）の間に約10％の差が出ます。

count = 9884
func1 time in clocks per iteration 7048685
count = 9884
func2 time in clocks per iteration 7661067
count = 9884
func3 time in clocks per iteration 8971878

これは以下でコンパイルされます： g++ -O3 -Wall -Wextra -std=gnu++0x -o vla vla.cpp

これがコードです：

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstdlib>

using namespace std;

const int SIZE = 1000000;

uint64_t g_val[SIZE];


static __inline__ unsigned long long rdtsc(void)
{
    unsigned hi, lo;
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
}


int func1(int x)
{
    int v[x];

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v[i] = rand() % x;
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}

int func2(int x)
{
    vector<int> v;
    v.resize(x); 

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v[i] = rand() % x;
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}    

int func3(int x)
{
    vector<int> v;

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v.push_back(rand() % x);
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}    

void runbench(int (*f)(int), const char *name)
{
    srand(41711211);
    uint64_t long t = rdtsc();
    int count = 0;
    for(int i = 20; i < 200; i++)
    {
        count += f(i);
    }
    t = rdtsc() - t;
    cout << "count = " << count << endl;
    cout << name << " time in clocks per iteration " << dec << t << endl;
}

struct function
{
    int (*func)(int);
    const char *name;
};


#define FUNC(f) { f, #f }

function funcs[] = 
{
    FUNC(func1),
    FUNC(func2),
    FUNC(func3),
}; 


int main()
{
    for(size_t i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++)
    {
        runbench(funcs[i].func, funcs[i].name);
    }
}

VLAとベクターについて

ベクターがVLA自体を利用できると考えましたか？VLAがない場合、ベクターは配列の特定の「スケール」、たとえば10、100、10000をストレージに指定する必要があるため、101アイテムを保持するために10000アイテムの配列を割り当てることになります。VLAを使用して、サイズを200に変更すると、アルゴリズムは200のみが必要であると想定し、200の項目配列を割り当てることができます。または、n * 1.5のバッファを割り当てることもできます。

とにかく、実行時に必要なアイテムの数がわかっている場合は、VLAの方がパフォーマンスが高い（Matsのベンチマークが示すように）と私は主張します。彼が示したのは、単純な2パスの反復です。ランダムなサンプルが繰り返し取られるモンテカルロシミュレーション、または各要素に対して複数回計算が行われる画像操作（Photoshopフィルターなど）について考えてみてください。各要素の各計算では、近傍の確認が必要になる可能性があります。

ベクトルからその内部配列への追加のポインタージャンプが加算されます。

主な質問に答える

ただし、LinkedListのような動的に割り当てられる構造の使用について話すとき、比較はありません。配列は、その要素へのポインタ演算を使用して直接アクセスを提供します。リンクされたリストを使用して、特定の要素に到達するためにノードをウォークする必要があります。したがって、このシナリオではVLAが勝者となります。

この回答によると、それはアーキテクチャに依存していますが、場合によっては、スタックがキャッシュで使用できるため、スタックへのメモリアクセスが高速になります。多数の要素がある場合、これは無効になる可能性があります（マットがベンチマークで見た利益の減少の原因となる可能性があります）。ただし、キャッシュサイズが大幅に増加しているため、それに応じてその数も増加する可能性があることに注意してください。

VLAを使用する理由は主にパフォーマンスです。ウィキの例を「無関係な」違いだけがあるとして無視するのは誤りです。たとえば、その関数がタイトなループで呼び出された場合、そのコードに大きな違いがある可能性があるケースを簡単に確認できます。read_val。IO関数は、速度が重要なある種のシステムで非常に迅速に返されました。

実際、VLAがこのように使用されるほとんどの場所では、VLAはヒープ呼び出しを置き換えるのではなく、次のようなものを置き換えます。

float vals[256]; /* I hope we never get more! */

ローカル宣言についての事はそれが非常に速いということです。この行はfloat vals[n]通常、2、3のプロセッサ命令のみを必要とします（おそらく1つだけです）。nスタックポインタにです。

一方、ヒープ割り当てでは、データ構造をウォークして空き領域を見つける必要があります。幸運な場合でも、時間はおそらく1桁長くなります。（nつまり、スタックに配置して呼び出すという行為mallocは、おそらく5〜10命令です。）ヒープに適切な量のデータがある場合は、おそらくもっと悪いことになります。こんなケースを見て驚かなかったmalloc実際のプログラムで100倍から1000倍遅いも。

もちろん、マッチングによってパフォーマンスにも影響がありますfree。おそらく、malloc呼び出しとです。

さらに、メモリの断片化の問題があります。小さな割り当てがたくさんあると、ヒープが断片化する傾向があります。断片化されたヒープは、メモリを浪費し、メモリの割り当てに必要な時間を増加させます。