Đặt lại mảng int C về 0: cách nhanh nhất?

Giả sử rằng chúng ta có T myarray[100]với T = int, unsigned int, long long int hoặc unsigned long long int, cách nhanh nhất để đặt lại tất cả nội dung của nó về 0 (không chỉ để khởi tạo mà còn đặt lại nội dung nhiều lần trong chương trình của tôi) ? Có thể với memset?

Câu hỏi tương tự cho một mảng động như T *myarray = new T[100].

memset(from <string.h>) có lẽ là cách chuẩn nhanh nhất, vì nó thường là một quy trình được viết trực tiếp trong lắp ráp và được tối ưu hóa bằng tay.

memset(myarray, 0, sizeof(myarray)); // for automatically-allocated arrays
memset(myarray, 0, N*sizeof(*myarray)); // for heap-allocated arrays, where N is the number of elements

Nhân tiện, trong C ++, cách thành ngữ sẽ là sử dụng std::fill(from <algorithm>):

std::fill(myarray, myarray+N, 0);

mà có thể được tối ưu hóa tự động thành một memset; Tôi khá chắc chắn rằng nó sẽ hoạt động nhanh như memsetđối với ints, trong khi nó có thể hoạt động kém hơn một chút đối với các loại nhỏ hơn nếu trình tối ưu hóa không đủ thông minh. Tuy nhiên, khi nghi ngờ, hồ sơ.

Câu hỏi này, mặc dù khá cũ, nhưng cần một số điểm chuẩn, vì nó yêu cầu không phải là cách thành ngữ nhất, hoặc cách có thể được viết với số dòng ít nhất, nhưng là cách nhanh nhất . Và thật ngớ ngẩn nếu trả lời câu hỏi đó mà không có một số thử nghiệm thực tế. Vì vậy, tôi đã so sánh bốn giải pháp, memset so với std :: fill so với ZERO của câu trả lời của AnT và giải pháp tôi đã thực hiện bằng cách sử dụng nội dung AVX.

Lưu ý rằng giải pháp này không chung chung, nó chỉ hoạt động trên dữ liệu 32 hoặc 64 bit. Vui lòng bình luận nếu mã này làm điều gì đó không chính xác.

#include<immintrin.h>
#define intrin_ZERO(a,n){\
size_t x = 0;\
const size_t inc = 32 / sizeof(*(a));/*size of 256 bit register over size of variable*/\
for (;x < n-inc;x+=inc)\
    _mm256_storeu_ps((float *)((a)+x),_mm256_setzero_ps());\
if(4 == sizeof(*(a))){\
    switch(n-x){\
    case 3:\
        (a)[x] = 0;x++;\
    case 2:\
        _mm_storeu_ps((float *)((a)+x),_mm_setzero_ps());break;\
    case 1:\
        (a)[x] = 0;\
        break;\
    case 0:\
        break;\
    };\
}\
else if(8 == sizeof(*(a))){\
switch(n-x){\
    case 7:\
        (a)[x] = 0;x++;\
    case 6:\
        (a)[x] = 0;x++;\
    case 5:\
        (a)[x] = 0;x++;\
    case 4:\
        _mm_storeu_ps((float *)((a)+x),_mm_setzero_ps());break;\
    case 3:\
        (a)[x] = 0;x++;\
    case 2:\
        ((long long *)(a))[x] = 0;break;\
    case 1:\
        (a)[x] = 0;\
        break;\
    case 0:\
        break;\
};\
}\
}

Tôi sẽ không khẳng định rằng đây là phương pháp nhanh nhất, vì tôi không phải là chuyên gia tối ưu hóa cấp thấp. Thay vào đó, nó là một ví dụ về việc triển khai phụ thuộc vào kiến ​​trúc chính xác nhanh hơn memset.

Bây giờ, vào kết quả. Tôi đã tính toán hiệu suất cho kích thước 100 int và các mảng dài dài, cả phân bổ tĩnh và động, nhưng ngoại trừ msvc, đã thực hiện loại bỏ mã chết trên các mảng tĩnh, kết quả cực kỳ so sánh, vì vậy tôi sẽ chỉ hiển thị hiệu suất mảng động. Dấu thời gian là ms cho 1 triệu lần lặp, sử dụng chức năng đồng hồ có độ chính xác thấp của time.h.

clang 3.8 (Sử dụng giao diện người dùng clang-cl, cờ tối ưu hóa = / OX / Arch: AVX / Oi / Ot)

int:
memset:      99
fill:        97
ZERO:        98
intrin_ZERO: 90

long long:
memset:      285
fill:        286
ZERO:        285
intrin_ZERO: 188

gcc 5.1.0 (cờ tối ưu hóa: -O3 -march = native -mtune = native -mavx):

int:
memset:      268
fill:        268
ZERO:        268
intrin_ZERO: 91
long long:
memset:      402
fill:        399
ZERO:        400
intrin_ZERO: 185

msvc 2015 (cờ tối ưu hóa: / OX / Arch: AVX / Oi / Ot):

int
memset:      196
fill:        613
ZERO:        221
intrin_ZERO: 95
long long:
memset:      273
fill:        559
ZERO:        376
intrin_ZERO: 188

Có rất nhiều điều thú vị đang diễn ra ở đây: llvm giết gcc, tối ưu hóa đốm sáng điển hình của MSVC (nó thực hiện loại bỏ mã chết ấn tượng trên các mảng tĩnh và sau đó có hiệu suất khủng khiếp cho việc lấp đầy). Mặc dù việc triển khai của tôi nhanh hơn đáng kể, nhưng điều này có thể chỉ là do nó nhận ra rằng việc xóa bit có chi phí ít hơn nhiều so với bất kỳ hoạt động cài đặt nào khác.

Việc triển khai của Clang đáng được xem xét nhiều hơn, vì nó nhanh hơn đáng kể. Một số thử nghiệm bổ sung cho thấy rằng memset của nó trên thực tế chuyên dùng cho các memset không - khác 0 cho mảng 400 byte chậm hơn nhiều (~ 220ms) và có thể so sánh với gcc. Tuy nhiên, việc thiết lập bộ nhớ nonzero với mảng 800 byte không tạo ra sự khác biệt về tốc độ, đó có thể là lý do tại sao trong trường hợp đó, bộ nhớ của họ có hiệu suất kém hơn so với cách thực hiện của tôi - chuyên môn hóa chỉ dành cho các mảng nhỏ và giới hạn đúng là khoảng 800 byte. Cũng lưu ý rằng gcc 'fill' và 'ZERO' không tối ưu hóa thành memset (xem mã được tạo), gcc chỉ đơn giản là tạo mã có các đặc điểm hiệu suất giống hệt nhau.

Kết luận: memset không thực sự được tối ưu hóa cho tác vụ này cũng như mọi người sẽ giả vờ như vậy (nếu không thì memset của gcc và msvc và llvm sẽ có cùng hiệu suất). Nếu vấn đề về hiệu suất thì memset không nên là giải pháp cuối cùng, đặc biệt là đối với các mảng có kích thước trung bình khó xử này, bởi vì nó không chuyên dụng để xóa bit và nó không được tối ưu hóa bằng tay tốt hơn so với việc trình biên dịch có thể tự làm.

Từ memset():

memset(myarray, 0, sizeof(myarray));

Bạn có thể sử dụng sizeof(myarray)nếu kích thước của myarrayđược biết trước tại thời điểm biên dịch. Ngược lại, nếu bạn đang sử dụng một mảng có kích thước động, chẳng hạn như thu được qua mallochoặc new, bạn sẽ cần theo dõi độ dài.

Bạn có thể sử dụng memset, nhưng chỉ vì lựa chọn loại của chúng tôi bị hạn chế đối với loại tích phân.

Trong trường hợp chung trong C, việc triển khai macro

#define ZERO_ANY(T, a, n) do{\
   T *a_ = (a);\
   size_t n_ = (n);\
   for (; n_ > 0; --n_, ++a_)\
     *a_ = (T) { 0 };\
} while (0)

Điều này sẽ cung cấp cho bạn chức năng giống như C ++ cho phép bạn "đặt lại về số không" một mảng các đối tượng thuộc bất kỳ loại nào mà không cần phải sử dụng đến các phương pháp hack như memset. Về cơ bản, đây là một dạng tương tự C của mẫu hàm C ++, ngoại trừ việc bạn phải chỉ định đối số kiểu một cách rõ ràng.

Trên hết, bạn có thể tạo một "mẫu" cho các mảng không bị phân rã

#define ARRAY_SIZE(a) (sizeof (a) / sizeof *(a))
#define ZERO_ANY_A(T, a) ZERO_ANY(T, (a), ARRAY_SIZE(a))

Trong ví dụ của bạn, nó sẽ được áp dụng là

int a[100];

ZERO_ANY(int, a, 100);
// or
ZERO_ANY_A(int, a);

Cũng cần lưu ý rằng đặc biệt đối với các đối tượng thuộc kiểu vô hướng, người ta có thể triển khai macro độc lập với kiểu

#define ZERO(a, n) do{\
   size_t i_ = 0, n_ = (n);\
   for (; i_ < n_; ++i_)\
     (a)[i_] = 0;\
} while (0)

và

#define ZERO_A(a) ZERO((a), ARRAY_SIZE(a))

biến ví dụ trên thành

 int a[100];

 ZERO(a, 100);
 // or
 ZERO_A(a);

Đối với khai báo tĩnh, tôi nghĩ bạn có thể sử dụng:

T myarray[100] = {0};

Đối với khai báo động, tôi đề xuất cách tương tự: memset

zero(myarray); là tất cả những gì bạn cần trong C ++.

Chỉ cần thêm điều này vào tiêu đề:

template<typename T, size_t SIZE> inline void zero(T(&arr)[SIZE]){
    memset(arr, 0, SIZE*sizeof(T));
}

Đây là chức năng tôi sử dụng:

template<typename T>
static void setValue(T arr[], size_t length, const T& val)
{
    std::fill(arr, arr + length, val);
}

template<typename T, size_t N>
static void setValue(T (&arr)[N], const T& val)
{
    std::fill(arr, arr + N, val);
}

Bạn có thể gọi nó như thế này:

//fixed arrays
int a[10];
setValue(a, 0);

//dynamic arrays
int *d = new int[length];
setValue(d, length, 0);

Trên đây là cách sử dụng C ++ 11 nhiều hơn so với sử dụng memset. Ngoài ra, bạn gặp lỗi thời gian biên dịch nếu bạn sử dụng mảng động với việc chỉ định kích thước.