10

TLDR：我忘记启用编译器优化。启用优化后，性能（几乎）相同。


原帖

从二进制数据中读取整数时，我注意到 memcpy 比强制转换解决方案慢。

版本 1：reinterpret_cast，由于潜在的对齐问题而异味，但也更快（？）

int get_int_v1(const char * data) { return *reinterpret_cast<const int*>(data); }

版本 2：memcpy，正确且慢一点：

int get_int_v2(const char * data) { int result; memcpy(&result, data, sizeof(result)); return result; }

我在 Ideone 上有一个基准。

为了将来参考，代码是：

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <vector>
#include <sys/time.h>

double get_current_time()
{
    timeval tv;
    gettimeofday(&tv, NULL);
    return double (tv.tv_sec) + 0.000001 * tv.tv_usec;
}

int get_int_v1(const char * data) { return *reinterpret_cast<const int*>(data); }
int get_int_v2(const char * data) { int result; memcpy(&result, data, sizeof(result)); return result; }

const unsigned iterations = 200 * 1000 * 1000;

double test_v1(const char * c, unsigned & prevent_optimization)
{
    double start = get_current_time();
    for (unsigned i = 0; i != iterations; ++i)
    {
        prevent_optimization += get_int_v1(c);
    }
    return get_current_time() - start;
}

double test_v2(const char * c, unsigned & prevent_optimization)
{
    double start = get_current_time();
    for (unsigned i = 0; i != iterations; ++i)
    {
        prevent_optimization += get_int_v2(c);
    }
    return get_current_time() - start;
}

int main()
{
    srand(time(0));

    // Initialize data
    std::vector<int> numbers(1000);
    for (std::vector<int>::size_type i = 0; i != numbers.size(); ++i)
    {
        numbers[i] = i;
    }

    // Repeat benchmark 4 times.
    for (unsigned i = 0; i != 4; ++i)
    {
        unsigned p = 0;
        std::vector<int>::size_type index = rand() % numbers.size();
        const char * c = reinterpret_cast<const char *>(&numbers[index]);    
        std::cout << "v1: " << test_v1(c, p) << std::endl;
        std::cout << "v2: " << test_v2(c, p) << std::endl << std::endl;
    }
}

结果是：

v1: 0.176457
v2: 0.557588

v1: 0.17654
v2: 0.220581

v1: 0.176826
v2: 0.22012

v1: 0.176131
v2: 0.220633

我的问题是：

  • 我的基准测试正确吗？
  • 如果是，那么为什么 v2（带有 memcpy）较慢？由于两个版本都返回数据的副本，我认为性能应该没有差异。
  • 如何实施正确且快速的解决方案？


更新

我很傻，忘了考虑 Ideone 不执行编译器优化。我还稍微调整了代码并提出了以下内容：

#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iomanip> 
#include <iostream> 
#include <vector>
#include <sys/time.h>

double get_current_time()
{
    timeval tv;
    gettimeofday(&tv, NULL);
    return double (tv.tv_sec) + 0.000001 * tv.tv_usec;
}

struct test_cast
{
    int operator()(const char * data) const 
    {
        return *((int*)data);
    }
};

struct test_memcpy
{
    int operator()(const char * data) const 
    {
        int result;
        memcpy(&result, data, sizeof(result));
        return result;
    }
};

struct test_std_copy
{
    int operator()(const char * data) const 
    {
        int result;
        std::copy(data, data + sizeof(int), reinterpret_cast<char *>(&result));
        return result;
    }
};

enum
{
    iterations = 2000,
    container_size = 2000
};

std::vector<int> get_random_numbers()
{
    std::vector<int> numbers(container_size);
    for (std::vector<int>::size_type i = 0; i != numbers.size(); ++i)
    {
        numbers[i] = rand();
    }
    return numbers;
}

std::vector<int> get_random_indices()
{
    std::vector<int> numbers(container_size);
    for (std::vector<int>::size_type i = 0; i != numbers.size(); ++i)
    {
        numbers[i] = i;
    }
    std::random_shuffle(numbers.begin(), numbers.end());
    return numbers;
}

template<typename Function>
unsigned benchmark(const Function & f, unsigned & counter)
{
    std::vector<int> container = get_random_numbers();
    std::vector<int> indices = get_random_indices();
    double start = get_current_time();
    for (unsigned iter = 0; iter != iterations; ++iter)
    {
        for (unsigned i = 0; i != container.size(); ++i)
        {
            counter += f(reinterpret_cast<const char*>(&container[indices[i]]));
        }
    }
    return unsigned(0.5 + 1000.0 * (get_current_time() - start));
}

int main()
{
    srand(time(0));
    unsigned counter = 0;

    std::cout << "cast:      " << benchmark(test_cast(),     counter) << " ms" << std::endl;
    std::cout << "memcpy:    " << benchmark(test_memcpy(),   counter) << " ms" << std::endl;
    std::cout << "std::copy: " << benchmark(test_std_copy(), counter) << " ms" << std::endl;
    std::cout << "(counter:  " << counter << ")" << std::endl << std::endl;

}

结果现在几乎相等（除了std::copy由于某种原因较慢）：

g++ -o test -O0 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      56 ms
memcpy:    60 ms
std::copy: 290 ms
(counter:  2854155632)

g++ -o test -O1 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      9 ms
memcpy:    14 ms
std::copy: 20 ms
(counter:  3524665968)

g++ -o test -O2 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      4 ms
memcpy:    5 ms
std::copy: 20 ms
(counter:  2590914608)

g++ -o test -O3 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      4 ms
memcpy:    5 ms
std::copy: 18 ms
(counter:  2590914608)
4

3 回答 3

8

您需要查看发出的代码。显然，优化器“应该”能够将memcpy转换为单个潜在未对齐int大小的读取到返回值，但是如果您看到不同的时间，那么我认为 x86 意味着它没有。

在我的机器上，使用 gcc-O2总是得到 0.09。我-O3总是得到 0 （我没有检查这是否比时间粒度更快，或者优化器是否删除了你的所有代码）。

所以很有可能，答案只是你没有使用正确的编译器标志（或者 ideone 没有）。

在可能未对齐的读取需要与对齐读取不同的指令的架构上，然后reinterpret_cast可能会发出对齐的读取，而memcpy可能必须发出未对齐的读取（取决于函数的调用方式——在这种情况下，数据实际上是对齐但我不知道编译器在什么条件下可以证明）。在那种情况下，我希望reinterpret_cast代码可能比 更快memcpy，但是在有人传入未对齐指针的情况下，这当然是不正确的。

于 2012-10-29T09:41:17.537 回答
6

强制转换是编译时操作，memcpy()而是运行时操作。这就是铸造对运行时间没有影响的原因。

于 2012-10-29T07:06:10.627 回答
3

memcpy无法复制到寄存器，它会进行内存到内存的复制。reinterpret_castin可以更改寄存器中保存的get_int_v1指针类型，甚至不需要寄存器到寄存器的副本。

于 2012-10-29T07:33:36.010 回答