Một ví dụ về chiều dài biến C tốt [đã đóng]

Câu hỏi này nhận được một sự tiếp nhận đóng băng tại SO, vì vậy tôi quyết định xóa nó ở đó và thử ở đây để thay thế. Nếu bạn nghĩ rằng nó cũng không phù hợp ở đây, ít nhất vui lòng để lại nhận xét về đề xuất cách tìm ví dụ tôi sau ...

Bạn có thể đưa ra một ví dụ , trong đó việc sử dụng C99 VLA mang lại lợi thế thực sự so với những thứ như cơ chế sử dụng C ++ RAII tiêu chuẩn hiện tại không?

Ví dụ tôi sau nên:

1. Đạt được lợi thế hiệu suất dễ dàng đo được (10% có thể) so với sử dụng heap.
2. Không có một cách giải quyết tốt, sẽ không cần toàn bộ mảng.
3. Thực tế được hưởng lợi từ việc sử dụng kích thước động, thay vì kích thước tối đa cố định.
4. Không thể gây ra tràn ngăn xếp trong kịch bản sử dụng bình thường.
5. Đủ mạnh để cám dỗ nhà phát triển cần hiệu năng để đưa tệp nguồn C99 vào dự án C ++.

Thêm một số làm rõ về ngữ cảnh: Ý tôi là VLA có nghĩa là C99 và không được bao gồm trong C ++ tiêu chuẩn: int array[n]đâu nlà một biến. Và tôi sau một ví dụ về trường hợp sử dụng trong đó nó bỏ qua các lựa chọn thay thế được cung cấp bởi các tiêu chuẩn khác (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

Một vài ý tưởng:

• Các hàm lấy varargs, tự nhiên giới hạn số lượng vật phẩm ở mức hợp lý, nhưng không có bất kỳ giới hạn trên mức API hữu ích nào.
• Hàm đệ quy, nơi ngăn xếp lãng phí là không mong muốn
• Nhiều phân bổ nhỏ và phát hành, trong đó chi phí heap sẽ là xấu.
• Xử lý các mảng đa chiều (như ma trận có kích thước tùy ý), trong đó hiệu suất là rất quan trọng và các chức năng nhỏ dự kiến ​​sẽ được đưa vào rất nhiều.
• Từ nhận xét: thuật toán đồng thời, trong đó phân bổ heap có phí đồng bộ hóa .

Wikipedia có một ví dụ không đáp ứng các tiêu chí của tôi , bởi vì sự khác biệt thực tế đối với việc sử dụng heap dường như không liên quan ít nhất là không có ngữ cảnh. Nó cũng không lý tưởng, vì nếu không có nhiều ngữ cảnh hơn, có vẻ như số lượng vật phẩm rất có thể gây ra tràn ngăn xếp.

Lưu ý: Tôi đặc biệt theo mã ví dụ hoặc đề xuất thuật toán sẽ có lợi cho việc này, để tôi tự thực hiện ví dụ.

Tôi vừa hack một chương trình nhỏ tạo ra một tập hợp các số ngẫu nhiên khởi động lại ở cùng một hạt giống mỗi lần, để đảm bảo rằng nó "công bằng" và "có thể so sánh". Khi nó đi cùng, nó chỉ ra tối thiểu và tối đa của các giá trị này. Và khi nó đã tạo ra tập hợp các số, nó sẽ đếm có bao nhiêu trên trung bình minvà max.

Đối với RẤT nhỏ mảng, nó cho thấy lợi ích rõ ràng với VLA hơn std::vector<>.

Đây không phải là vấn đề thực sự, nhưng chúng ta có thể dễ dàng tưởng tượng thứ gì đó mà chúng ta sẽ đọc các giá trị từ một tệp nhỏ thay vì sử dụng các số ngẫu nhiên và thực hiện một số phép tính đếm / phút / tối đa khác có ý nghĩa hơn với cùng một loại mã .

Đối với RẤT các giá trị nhỏ của "số lượng số ngẫu nhiên" (x) trong các hàm có liên quan, vlagiải pháp sẽ thắng với một mức chênh lệch lớn. Khi kích thước lớn hơn, "phần thắng" sẽ nhỏ hơn và được cung cấp đủ kích thước, giải pháp vectơ có vẻ hiệu quả hơn - không nghiên cứu biến thể đó quá nhiều, vì khi chúng ta bắt đầu có hàng ngàn phần tử trong một VLA, thì không thực sự những gì họ dự định làm ...

Và tôi chắc chắn rằng ai đó sẽ nói với tôi rằng có một số cách viết tất cả mã này với một loạt các mẫu và làm cho nó thực hiện điều này mà không cần chạy nhiều hơn RDTSC và coutcác bit khi chạy ... Nhưng tôi không nghĩ đó thực sự là điểm

Khi chạy biến thể đặc biệt này, tôi nhận được khoảng 10% chênh lệch giữa func1(VLA) và 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

Điều này được biên soạn với: g++ -O3 -Wall -Wextra -std=gnu++0x -o vla vla.cpp

Đây là mã:

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

Về VLAs so với Vector

Bạn có nghĩ rằng một Vector có thể tận dụng lợi thế của chính VLAs. Không có VLAs, Vector phải chỉ định một số "thang" nhất định của mảng, ví dụ 10, 100, 10000 để lưu trữ để cuối cùng bạn phân bổ một mảng 10000 vật phẩm để chứa 101 vật phẩm. Với VLAs, nếu bạn thay đổi kích thước thành 200, thuật toán có thể cho rằng bạn sẽ chỉ cần 200 và có thể phân bổ một mảng 200 mặt hàng. Hoặc nó có thể phân bổ một bộ đệm nói n * 1.5.

Dù sao, tôi lập luận rằng nếu bạn biết bạn cần bao nhiêu vật phẩm trong thời gian chạy, thì một VLA có hiệu suất cao hơn (như tiêu chuẩn của Mats đã thể hiện). Những gì ông đã chứng minh là một lần lặp hai lần đơn giản. Hãy nghĩ về mô phỏng monte carlo trong đó các mẫu ngẫu nhiên được thực hiện lặp đi lặp lại hoặc thao tác hình ảnh (như bộ lọc Photoshop) trong đó việc tính toán được thực hiện trên mỗi phần tử nhiều lần và hoàn toàn có thể mỗi tính toán trên mỗi phần tử liên quan đến việc nhìn vào hàng xóm.

Con trỏ thêm đó nhảy từ vectơ đến mảng bên trong của nó cộng lại.

Trả lời câu hỏi chính

Nhưng khi bạn nói về việc sử dụng cấu trúc được phân bổ động như LinkedList, không có so sánh. Một mảng cung cấp truy cập trực tiếp bằng cách sử dụng số học con trỏ đến các phần tử của nó. Sử dụng một danh sách được liên kết, bạn phải đi bộ các nút để đến một yếu tố cụ thể. Vì vậy, VLA chiến thắng trong kịch bản này.

Theo câu trả lời này , nó phụ thuộc vào kiến ​​trúc, nhưng trong một số trường hợp, việc truy cập bộ nhớ trên ngăn xếp sẽ nhanh hơn do ngăn xếp có sẵn trên bộ đệm. Với một số lượng lớn các yếu tố, điều này có thể bị phủ nhận (có khả năng là nguyên nhân của lợi nhuận giảm dần mà Mats thấy trong điểm chuẩn của mình). Tuy nhiên, điều đáng chú ý là kích thước Cache đang tăng lên đáng kể và bạn có thể sẽ thấy số lượng đó tăng lên tương ứng.

Lý do để sử dụng VLA chủ yếu là hiệu suất. Đó là một sai lầm khi coi thường ví dụ wiki là chỉ có một sự khác biệt "không liên quan". Tôi có thể dễ dàng thấy các trường hợp mà chính xác mã đó có thể có một sự khác biệt rất lớn, ví dụ, nếu hàm đó được gọi trong một vòng lặp chặt chẽ, read_valthì hàm IO trở lại rất nhanh trên một loại hệ thống có tốc độ rất quan trọng.

Trên thực tế, ở hầu hết các nơi sử dụng VLAs theo cách này, họ không thay thế các cuộc gọi heap mà thay vào đó thay thế một số thứ như:

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

Điều về bất kỳ tuyên bố địa phương là nó cực kỳ nhanh chóng. Dòng float vals[n]thường chỉ yêu cầu một vài hướng dẫn của bộ xử lý (có thể chỉ là một.) Nó chỉ đơn giản là thêm giá trị vào ncon trỏ ngăn xếp.

Mặt khác, phân bổ heap yêu cầu đi bộ cấu trúc dữ liệu để tìm một khu vực miễn phí. Thời gian có lẽ là một thứ tự cường độ dài hơn ngay cả trong trường hợp may mắn nhất. (Tức là chỉ hành động đặt nlên ngăn xếp và gọi malloccó lẽ là 5-10 hướng dẫn.) Có lẽ tồi tệ hơn nhiều nếu có bất kỳ lượng dữ liệu hợp lý nào trong đống. Tôi sẽ không ngạc nhiên khi thấy một trường hợp mallocchậm hơn 100 lần đến 1000 lần trong một chương trình thực sự.

Tất nhiên, sau đó bạn cũng có một số tác động hiệu suất với kết hợp free, có thể tương tự như cường độ của malloccuộc gọi.

Ngoài ra, có vấn đề phân mảnh bộ nhớ. Rất nhiều phân bổ nhỏ có xu hướng phân mảnh đống. Phân mảnh đống cả bộ nhớ lãng phí và tăng thời gian cần thiết để phân bổ bộ nhớ.