Question

我有一个内存块，它被分成一系列位置，可以通过客户端代码检索和返回返回位置的方法如下所示：

void ReturnLocation(void *address) {
    int location = AddressToLocation(address); // I need the location here
    // some code
    DoSmthA(location);
}

void DoSmthA(int location) {
    // I need the address, but also the location
    void *address = LocationToAddress(location); 
    // do something with the address
    DoSmthB(location);
}

void DoSmthB(int location) {
    // Again, I need the address, but also the location
    void *address = LocationToAddress(location);
    // do something with the address
    DoSmthC(location); // It may go on this way...
}

// ------------------------------------------------------
void* LocationToAddress(int location)
{
    return (void *)((char *)this + HEADER_SIZE + (location * LocationSize));
}

int AddressToLocation(void *address)
{
    return (int)(((__int64)address - HEADER_SIZE - (__int64)this) / LocationSize);
}

我的问题是：我应该只将位置传递给辅助方法，还是每次传递地址的速度更快（而不是一次又一次地计算）：

void DoSmthA(int location, void *address) { }

甚至更好地使用这样的结构：

struct LocationInfo { int Location; void *Address; };
void DoSmthA(LocationInfo locInfo) { }

这种方法可能被称为百万次，我不确定从位置计算地址的操作（两次加法和一次乘法）是否比传递包含地址的第二个参数更快或更慢。

提前致谢！

Answer 1

描述它。在您的情况下，在您的编译器和代码库中更快地执行实际的操作。在我无关的测试中，不是我的无关编译器中的速度更快。

将参数传递给函数是一种非常便宜的操作。基本上是一个堆栈推/弹。

计算位置可能非常快，如果可以优化除法（取决于LocationSize的值，以及它是否在编译时已知）。

所以试试两者，看看哪个在现实世界中更快。

CPU是复杂的野兽，性能并非微不足道。

Answer 2

您正在进行一种优化，其中CPU /编译器甚至内存控制器的不同组合可以产生影响。我们只讨论1,000,000个操作，除非你添加几个0，我认为你甚至无法测量性能上的差异。所以，做任何更容易维护的事情。开发人员时间是IMO的100倍机器时间。

Answer 3

假设你确实知道这是一个瓶颈（你通过运行一个分析器来解决这个问题，而不仅仅是'知道'它的百万次运行是瓶颈，对吗？），正确的解决方案是尝试每个并查看哪个一个人有最好的改进。或者查看生成的程序集，看看哪个更好，如果你疯了。

将可选参数传递给方法而不是计算它的成本

3 个答案: