Contoh Array Panjang Variabel C yang bagus [ditutup]

Pertanyaan ini mendapat agak dingin di SO, jadi saya memutuskan untuk menghapusnya di sana dan coba di sini. Jika menurut Anda tidak cocok di sini, setidaknya tinggalkan komentar tentang saran bagaimana menemukan contoh yang saya cari ...

Bisakah Anda memberikan contoh , di mana menggunakan C99 VLA menawarkan keuntungan nyata dibandingkan dengan sesuatu seperti mekanisme CAIA RAPB-tumpukan standar saat ini?

Contoh yang saya cari harus:

1. Dapatkan keunggulan kinerja yang mudah diukur (10% mungkin) dibandingkan menggunakan heap.
2. Tidak memiliki solusi yang baik, yang tidak perlu seluruh array sama sekali.
3. Sebenarnya mendapat manfaat dari menggunakan ukuran dinamis, bukan ukuran maksimum tetap.
4. Tidak mungkin menyebabkan stack overflow dalam skenario penggunaan normal.
5. Cukup kuat untuk menggoda pengembang yang membutuhkan kinerja untuk memasukkan file sumber C99 dalam proyek C ++.

Menambahkan beberapa klarifikasi pada konteks: Maksud saya VLA sebagaimana dimaksud oleh C99 dan tidak termasuk dalam standar C ++: di int array[n]mana nadalah variabel. Dan saya mencari contoh use case yang mengalahkan alternatif yang ditawarkan oleh standar lain (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

Beberapa ide:

• Fungsi mengambil varargs, yang secara alami membatasi jumlah barang untuk sesuatu yang masuk akal, namun tanpa batas atas tingkat API yang berguna.
• Fungsi rekursif, di mana tumpukan sia-sia tidak diinginkan
• Banyak alokasi dan rilis kecil, di mana tumpukan overhead akan buruk.
• Menangani array multi-dimensi (seperti matriks ukuran sewenang-wenang), di mana kinerjanya sangat penting, dan fungsi-fungsi kecil diharapkan banyak mendapat inline.
• Dari komentar: algoritma bersamaan, di mana alokasi tumpukan memiliki overhead sinkronisasi .

Wikipedia memiliki contoh yang tidak memenuhi kriteria saya , karena perbedaan praktis untuk menggunakan tumpukan tampaknya tidak relevan setidaknya tanpa konteks. Ini juga tidak ideal, karena tanpa lebih banyak konteks, tampaknya jumlah barang dapat menyebabkan stack overflow.

Catatan: Saya secara khusus mencari kode contoh, atau saran algoritma yang akan mendapat manfaat dari ini, bagi saya untuk mengimplementasikan contoh itu sendiri.

Saya baru saja meretas sebuah program kecil yang menghasilkan satu set angka acak memulai kembali pada seed yang sama setiap kali, untuk memastikan bahwa itu "adil" dan "sebanding". Seiring berjalannya waktu, ia mencari min dan max dari nilai-nilai ini. Dan ketika telah menghasilkan himpunan angka, itu menghitung berapa banyak yang di atas rata-rata mindan max.

Untuk array SANGAT kecil, ini menunjukkan manfaat yang jelas dengan berakhirnya VLA std::vector<>.

Ini bukan masalah nyata, tetapi kita dapat dengan mudah membayangkan sesuatu di mana kita akan membaca nilai-nilai dari file kecil daripada menggunakan angka acak, dan melakukan beberapa perhitungan penghitungan / min / maks lainnya yang lebih bermakna dengan jenis kode yang sama .

Untuk nilai SANGAT kecil dari "jumlah angka acak" (x) dalam fungsi yang relevan, vlasolusi menang dengan margin yang sangat besar. Ketika ukurannya semakin besar, "win" semakin kecil, dan diberi ukuran yang cukup, solusi vektor tampaknya LEBIH efisien - tidak mempelajari varian terlalu banyak, seperti ketika kita mulai memiliki ribuan elemen dalam VLA, itu bukan sungguh apa yang seharusnya mereka lakukan ...

Dan saya yakin seseorang akan memberi tahu saya bahwa ada beberapa cara untuk menulis semua kode ini dengan banyak templat dan menyelesaikannya tanpa menjalankan lebih dari RDTSC dan coutbit saat runtime ... Tapi saya tidak berpikir itu benar-benar inti nya.

Saat menjalankan varian khusus ini, saya mendapatkan sekitar 10% perbedaan antara func1(VLA) dan func2(std :: vector).

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

Ini dikompilasi dengan: g++ -O3 -Wall -Wextra -std=gnu++0x -o vla vla.cpp

Berikut kodenya:

#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);
    }
}

Mengenai VLA versus Vektor

Apakah Anda menganggap bahwa suatu Vektor dapat memanfaatkan VLA itu sendiri. Tanpa VLA, Vector harus menentukan "skala" array misalnya 10, 100, 10000 untuk penyimpanan sehingga Anda akhirnya mengalokasikan 10.000 item array untuk menampung 101 item. Dengan VLA, jika Anda mengubah ukuran menjadi 200, algoritme mungkin mengasumsikan bahwa Anda hanya perlu 200 dan dapat mengalokasikan 200 item array. Atau dapat mengalokasikan buffer dari say n * 1.5.

Ngomong-ngomong, saya berpendapat bahwa jika Anda tahu berapa banyak item yang akan Anda butuhkan saat runtime, VLA lebih performan (seperti yang ditunjukkan oleh benchmark Mats '). Apa yang dia tunjukkan adalah iterasi dua pass sederhana. Pikirkan simulasi monte carlo di mana sampel acak diambil berulang kali, atau manipulasi gambar (seperti filter Photoshop) di mana perhitungan dilakukan pada setiap elemen beberapa kali dan sangat mungkin setiap perhitungan pada setiap elemen melibatkan melihat tetangga.

Penunjuk ekstra itu melompat dari vektor ke susunan internalnya bertambah.

Menjawab pertanyaan utama

Tetapi ketika Anda berbicara tentang menggunakan struktur yang dialokasikan secara dinamis seperti LinkedList, tidak ada perbandingan. Array menyediakan akses langsung menggunakan pointer aritmatika ke elemen-elemennya. Menggunakan daftar tertaut, Anda harus berjalan di titik untuk mendapatkan elemen tertentu. Jadi VLA menang telak dalam skenario ini.

Menurut jawaban ini , secara arsitektur tergantung, tetapi dalam beberapa kasus akses memori pada stack akan lebih cepat karena stack tersedia pada cache. Dengan sejumlah besar elemen ini dapat dinegasikan (berpotensi menjadi penyebab berkurangnya pengembalian yang dilihat Mats dalam tolok ukurnya). Namun, perlu dicatat bahwa ukuran Cache tumbuh secara signifikan dan Anda akan berpotensi melihat lebih banyak dari itu.

Alasan untuk menggunakan VLA terutama karena kinerja. Merupakan kesalahan untuk mengabaikan contoh wiki karena hanya memiliki perbedaan "tidak relevan". Saya dapat dengan mudah melihat kasus-kasus di mana tepatnya kode itu dapat memiliki perbedaan besar, misalnya, jika fungsi itu disebut dalam loop ketat, di mana read_valada fungsi IO yang kembali sangat cepat pada semacam sistem di mana kecepatan sangat penting.

Bahkan, di sebagian besar tempat di mana VLA digunakan dengan cara ini, mereka tidak mengganti panggilan tumpukan tetapi malah mengganti sesuatu seperti:

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

Hal tentang deklarasi lokal adalah bahwa itu sangat cepat. Garis float vals[n]umumnya hanya memerlukan beberapa instruksi prosesor (mungkin hanya satu.) Itu hanya menambah nilai nke stack pointer.

Di sisi lain, alokasi tumpukan memerlukan berjalan struktur data untuk menemukan area bebas. Waktu mungkin urutan besarnya lebih lama bahkan dalam kasus paling beruntung. (Yaitu hanya tindakan menempatkan ndi tumpukan dan menelepon mallocmungkin 5-10 instruksi.) Mungkin jauh lebih buruk jika ada jumlah data yang wajar di heap. Sama sekali tidak mengejutkan saya untuk melihat kasus di mana malloc100x hingga 1000x lebih lambat dalam program nyata.

Tentu saja, maka Anda juga memiliki beberapa dampak kinerja dengan pencocokan free, mungkin sama besarnya dengan mallocpanggilan.

Selain itu, ada masalah fragmentasi memori. Banyak alokasi kecil cenderung memecah tumpukan. Tumpukan yang terfragmentasi membuang-buang memori dan menambah waktu yang dibutuhkan untuk mengalokasikan memori.