效率int与long long任务

Question

如果我需要给一块内存分配零。如果体系结构是32位，那么long long (在特定体系结构上是8字节)的赋值是否比int (4字节)的赋值更有效，或者它是否等于两个int赋值？对于相同的内存块，int的分配是否比使用char的分配更有效，因为如果我使用char而不是int，我将需要4倍的循环次数

Answer 1

为什么不使用memset()？

http://www.elook.org/programming/c/memset.html

(来自上述网站)

语法：

#include <string.h>
void *memset( void *buffer, int ch, size_t count ); 

描述：

函数memset()将ch复制到buffer的第一个计数字符中，并返回buffer。memset()对于将一段内存初始化为某个值很有用。例如，此命令：

memset( the_array, '\0', sizeof(the_array) ); 

是将the_array的所有值设置为零的一种非常有效的方法。

Answer 2

对于你的问题，答案是肯定的，如果编译器是智能的/优化的。

有趣的是，在具有SSE的机器上，我们可以使用128位块:)尽管如此，这只是我的观点，始终努力强调可读性与简洁性的平衡，所以是的……我倾向于使用memset，它并不总是完美的，也可能不是最快的，但它会告诉维护代码的人“嘿，我正在初始化或设置这个数组”。

无论如何，这里有一些测试代码，如果需要任何更正，请让我知道。

#include <time.h>
#include <xmmintrin.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define NUMBER_OF_VALUES 33554432

int main()
{
    int *values;
    int result = posix_memalign((void *)&values, 16, NUMBER_OF_VALUES * sizeof(int));
    if (result)
    {
        printf("Failed to mem allocate \n");
        exit(-1);
    }
    clock_t start, end;

    int *temp = values, total = NUMBER_OF_VALUES; 
    while (total--)
        *temp++ = 0;

    start = clock();
    memset(values, 0, sizeof(int) * NUMBER_OF_VALUES);
    end = clock();

    printf("memset time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        int index = 0, total = NUMBER_OF_VALUES * sizeof(int);
        char *temp = (char *)values;
        for(; index < total; index++)
            temp[index] = 0;
    }
    end = clock();

    printf("char-wise for-loop array indices time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        int index = 0, *temp = values, total = NUMBER_OF_VALUES;
        for (; index < total; index++)
            temp[index] = 0;
    }
    end = clock();

    printf("int-wise for-loop array indices time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        int index = 0, total = NUMBER_OF_VALUES/2;
        long long int *temp = (long long int *)values;
        for (; index < total; index++)
            temp[index] = 0;
    }
    end = clock();

    printf("long-long-int-wise for-loop array indices time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
       int index = 0, total = NUMBER_OF_VALUES/4;
       __m128i zero = _mm_setzero_si128();
       __m128i *temp = (__m128i *)values;
       for (; index < total; index++)
           temp[index] = zero; 
    }
    end = clock();

    printf("SSE-wise for-loop array indices time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        char *temp = (char *)values;
        int total  = NUMBER_OF_VALUES * sizeof(int);
        while (total--)
            *temp++ = 0;        
    }
    end = clock();

    printf("char-wise while-loop pointer arithmetic time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        int *temp = values, total = NUMBER_OF_VALUES;
        while (total--)
            *temp++ = 0;
    }
    end = clock();

    printf("int-wise while-loop pointer arithmetic time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        long long int *temp = (long long int *)values;
        int total = NUMBER_OF_VALUES/2;
        while (total--)
            *temp++ = 0;
    }
    end = clock();

    printf("long-ling-int-wise while-loop pointer arithmetic time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);

    start = clock();
    {
        __m128i zero = _mm_setzero_si128();
        __m128i *temp = (__m128i *)values;
        int total = NUMBER_OF_VALUES/4;
        while (total--)
            *temp++ = zero;
    }
    end = clock();

    printf("SSE-wise while-loop pointer arithmetic time %f\n", ((double) (end - start)) / CLOCKS_PER_SEC);


    free(values);
    return 0;
}

以下是一些测试：

$ gcc time.c
$ ./a.out 
memset time 0.025350
char-wise for-loop array indices time 0.334508
int-wise for-loop array indices time 0.089259
long-long-int-wise for-loop array indices time 0.046997
SSE-wise for-loop array indices time 0.028812
char-wise while-loop pointer arithmetic time 0.271187
int-wise while-loop pointer arithmetic time 0.072802
long-ling-int-wise while-loop pointer arithmetic time 0.039587
SSE-wise while-loop pointer arithmetic time 0.030788

$ gcc -O2 -Wall time.c
MacBookPro:~ samyvilar$ ./a.out 
memset time 0.025129
char-wise for-loop array indices time 0.084930
int-wise for-loop array indices time 0.025263
long-long-int-wise for-loop array indices time 0.028245
SSE-wise for-loop array indices time 0.025909
char-wise while-loop pointer arithmetic time 0.084485
int-wise while-loop pointer arithmetic time 0.025277
long-ling-int-wise while-loop pointer arithmetic time 0.028187
SSE-wise while-loop pointer arithmetic time 0.025823

我的信息：

$ gcc --version
i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5666) (dot 3)
Copyright (C) 2007 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ uname -a
Darwin MacBookPro 10.8.0 Darwin Kernel Version 10.8.0: Tue Jun  7 16:33:36 PDT 2011; root:xnu-1504.15.3~1/RELEASE_I386 i386

memset是非常优化的，可能是使用内联汇编，尽管这在编译器之间也是不同的……

当给-O2一些时间开始收敛时，gcc似乎在积极地进行优化，我想我应该看看程序集。

如果您很好奇，只需调用gcc -S -msse2 -O2 -Wall time.c，程序集位于time.s

Answer 3

在高级编程语言中总是避免额外的迭代。如果你只迭代一次int，而不是遍历它的字节，你的代码将会更有效率。