1

我有一个需要重复多次的数字序列，并将重复的数据作为指向沿大小的数据的指针（实际上是元素计数）。我需要将这些数据传递给 API。

分配内存，传递重复数据然后再次释放它的最有效方法是什么。我目前有需要重复存储在 std::vector 中的序列

我有几个想法是这样的：

// Setup code
unsigned int repeat = 30000;
std::vector<int> datavector(5, 0); // assume this would contain arbitrary numbers that needed to be repeated

// Idea 1:
{
    unsigned int byte_size_step = datavector.size() * sizeof(int);
    unsigned int byte_full_size = byte_size_step * repeat;
    int *ptr = malloc(byte_full_size);

    for(unsigned int i=0; i<repeat; i++)
    {
        memcpy(ptr+(i*byte_size_step), datavector.data(),  byte_size_step);
    }
    apiFunc(ptr); // apiFunc copies the data
    free(ptr)
}

// Idea 2:
{
    std::vector datarepeated(datavector.size()*repeat);
    for(unsigned int i=0; i<repeat; i++)
    {
        datarepeated.insert(datarepeated.begin()+(i*size_step), datavector.begin(), datavector.end());
    }
    apiFunc(datarepeated.data());
}

虽然我觉得会有一个功能或易于使用的方法来快速重复内存中的序列。我可能错过了一些东西。我个人不知道这样的事情是否可以从多线程解决方案中受益。

欢迎任何可以（最）有效地做到这一点的提示。

4

1 回答 1

2

您的两个想法都应该具有非常相似的性能。但是，您可以通过最小化循环迭代/调用的数量来从中挤出更多性能memcpy，您可以通过将每次迭代的长度加倍来实现。像这样的东西：

// Setup code
const size_t repeat = 10;
int data[] = {1, 2, 3, 4, 5};
vector<int> datavec(data, data+5);

// initialize and copy initial segment
vector<int> datarepeated(datavec.size() * repeat);
memcpy(&datarepeated[0], &datavec[0], datavec.size()*sizeof(int));
size_t num_copied = datavec.size();
size_t num_total = datarepeated.size();

// double the amount copied at each iteration
while(num_copied*2 <= num_total) {
    memcpy(&datarepeated[num_copied], &datarepeated[0], num_copied*sizeof(int));
    num_copied *= 2;
}

// copy the final bit
if(num_copied < num_total)
    memcpy(&datarepeated[num_copied], &datarepeated[0], (num_total-num_copied)*sizeof(int));

您可以在这里看到它的实际效果。

编辑：当然，您可以尝试在循环内进行复制的方式的变化（例如，而不是memcpy,与评论中建议的人一起使用std::copya ）。我试图表达的关键思想是重复加倍。无论您最终尝试什么，请务必进行基准测试。back_inserterwhile

于 2013-09-12T23:59:09.167 回答