Question

我正在使用free来释放在递归函数中为一堆临时数组分配的内存。我会发布代码，但它很长。当我注释掉这些free（）调用时，程序运行不到一秒钟。但是，当我使用它们时，程序运行大约需要20秒。为什么会发生这种情况，如何解决？这就像是100左右的MB所以我宁愿不要只留下内存泄漏。

此外，当我运行包含所有启用了性能分析的free（）调用的程序时，它会在不到一秒的时间内运行。我不知道这会产生什么效果，但确实如此。

在仅使用一些free（）调用之后，似乎有一些特别导致程序变慢。其余的似乎没有效果。

好的......这是所要求的代码：

void KDTree::BuildBranch(int height, Mailbox** objs, int nObjects)
{
int dnObjects = nObjects * 2;
int dnmoObjects = dnObjects - 1;

//Check for termination
if(height == -1 || nObjects < minObjectsPerNode)
{
    //Create leaf
    tree[nodeIndex] = KDTreeNode();

    if(nObjects == 1)
        tree[nodeIndex].InitializeLeaf(objs[0], 1);
    else
        tree[nodeIndex].InitializeLeaf(objs, nObjects);

    //Added a node, increment index
    nodeIndex++;

    return;
}

//Save this node's index and increment the current index to save space for this node
int thisNodeIndex = nodeIndex;
nodeIndex++;

//Allocate memory for split options
float* xMins = (float*)malloc(nObjects * sizeof(float));
float* yMins = (float*)malloc(nObjects * sizeof(float));
float* zMins = (float*)malloc(nObjects * sizeof(float));
float* xMaxs = (float*)malloc(nObjects * sizeof(float));
float* yMaxs = (float*)malloc(nObjects * sizeof(float));
float* zMaxs = (float*)malloc(nObjects * sizeof(float));

//Find all possible split locations
int index = 0;
BoundingBox* tempBox = new BoundingBox();
for(int i = 0; i < nObjects; i++)
{
    //Get bounding box
    objs[i]->prim->MakeBoundingBox(tempBox);

    //Add mins to split lists
    xMins[index] = tempBox->x0;
    yMins[index] = tempBox->y0;
    zMins[index] = tempBox->z0;

    //Add maxs
    xMaxs[index] = tempBox->x1;
    yMaxs[index] = tempBox->y1;
    zMaxs[index] = tempBox->z1;
    index++;
}

//Sort lists
Util::sortFloats(xMins, nObjects);
Util::sortFloats(yMins, nObjects);
Util::sortFloats(zMins, nObjects);
Util::sortFloats(xMaxs, nObjects);
Util::sortFloats(yMaxs, nObjects);
Util::sortFloats(zMaxs, nObjects);

//Allocate bin lists
Bin* xLeft = (Bin*)malloc(dnObjects * sizeof(Bin));
Bin* xRight = (Bin*)malloc(dnObjects * sizeof(Bin));
Bin* yLeft = (Bin*)malloc(dnObjects * sizeof(Bin));
Bin* yRight = (Bin*)malloc(dnObjects * sizeof(Bin));
Bin* zLeft = (Bin*)malloc(dnObjects * sizeof(Bin));
Bin* zRight = (Bin*)malloc(dnObjects * sizeof(Bin));

//Initialize all bins
for(int i = 0; i < dnObjects; i++)
{
    xLeft[i] = Bin(0, 0.0f);
    xRight[i] = Bin(0, 0.0f);
    yLeft[i] = Bin(0, 0.0f);
    yRight[i] = Bin(0, 0.0f);
    zLeft[i] = Bin(0, 0.0f);
    zRight[i] = Bin(0, 0.0f);
}

//Construct min and max bins bins from split locations
//Merge min/max lists together for each axis
int minIndex = 0, maxIndex = 0;
for(int i = 0; i < dnObjects; i++)
{
    if(maxIndex == nObjects || (xMins[minIndex] <= xMaxs[maxIndex] && minIndex != nObjects))
    {
        //Add split location to both bin lists
        xLeft[i].rightEdge = xMins[minIndex];
        xRight[i].rightEdge = xMins[minIndex];
        //Add geometry to mins counter
        xLeft[i+1].objectBoundCounter++;

        minIndex++;
    }
    else
    {
        //Add split location to both bin lists
        xLeft[i].rightEdge = xMaxs[maxIndex];
        xRight[i].rightEdge = xMaxs[maxIndex];
        //Add geometry to maxs counter
        xRight[i].objectBoundCounter++;

        maxIndex++;
    }
}

//Repeat for y axis
minIndex = 0, maxIndex = 0;
for(int i = 0; i < dnObjects; i++)
{
    if(maxIndex == nObjects || (yMins[minIndex] <= yMaxs[maxIndex] && minIndex != nObjects))
    {
        //Add split location to both bin lists
        yLeft[i].rightEdge = yMins[minIndex];
        yRight[i].rightEdge = yMins[minIndex];
        //Add geometry to mins counter
        yLeft[i+1].objectBoundCounter++;

        minIndex++;
    }
    else
    {
        //Add split location to both bin lists
        yLeft[i].rightEdge = yMaxs[maxIndex];
        yRight[i].rightEdge = yMaxs[maxIndex];
        //Add geometry to maxs counter
        yRight[i].objectBoundCounter++;

        maxIndex++;
    }
}

//Repeat for z axis
minIndex = 0, maxIndex = 0;
for(int i = 0; i < dnObjects; i++)
{
    if(maxIndex == nObjects || (zMins[minIndex] <= zMaxs[maxIndex] && minIndex != nObjects))
    {
        //Add split location to both bin lists
        zLeft[i].rightEdge = zMins[minIndex];
        zRight[i].rightEdge = zMins[minIndex];
        //Add geometry to mins counter
        zLeft[i+1].objectBoundCounter++;

        minIndex++;
    }
    else
    {
        //Add split location to both bin lists
        zLeft[i].rightEdge = zMaxs[maxIndex];
        zRight[i].rightEdge = zMaxs[maxIndex];
        //Add geometry to maxs counter
        zRight[i].objectBoundCounter++;

        maxIndex++;
    }
}

//Free split memory
free(xMins);
free(xMaxs);
free(yMins);
free(yMaxs);
free(zMins);
free(zMaxs);

//PreCalcs
float voxelL = xRight[dnmoObjects].rightEdge - xLeft[0].rightEdge;
float voxelD = zRight[dnmoObjects].rightEdge - zLeft[0].rightEdge;
float voxelH = yRight[dnmoObjects].rightEdge - yLeft[0].rightEdge;

float voxelSA = 2.0f * voxelL * voxelD + 2.0f * voxelL * voxelH + 2.0f * voxelD * voxelH;

//Minimum cost preset to no split at all
float minCost = (float)nObjects;
float splitLoc;
int minLeftCounter = 0, minRightCounter = 0;
int axis = -1;

 //---------------------------------------------------------------------------------------------
//Check costs of x-axis split planes keeping track of derivative using
//the fact that there is a minimum point on the graph costs vs split location
//Since there is one object per split plane
int splitIndex = 1;
float lastCost = nObjects * voxelL;
float tempCost;
float lastSplit = xLeft[1].rightEdge;
int leftCount = xLeft[1].objectBoundCounter, rightCount = nObjects - xRight[1].objectBoundCounter;
int lastLO = 0, lastRO = nObjects;
//Keep looping while cost is decreasing
while(splitIndex < dnObjects)
{
    tempCost = leftCount * (xLeft[splitIndex].rightEdge - xLeft[0].rightEdge) + rightCount * (xLeft[dnmoObjects].rightEdge - xLeft[splitIndex].rightEdge);
    if(tempCost < lastCost)
    {
        lastCost = tempCost;
        lastSplit = xLeft[splitIndex].rightEdge;
        lastLO = leftCount;
        lastRO = rightCount;
    }

    //Update counters
    splitIndex++;
    leftCount += xLeft[splitIndex].objectBoundCounter;
    rightCount -= xRight[splitIndex].objectBoundCounter;
}

//Calculate full SAH cost
lastCost = ((lastLO * (2 * (lastSplit - xLeft[0].rightEdge) * voxelD + 2 * (lastSplit - xLeft[0].rightEdge) * voxelH + 2 * voxelD * voxelH)) + (lastRO * (2 * (xLeft[dnmoObjects].rightEdge - lastSplit) * voxelD + 2 * (xLeft[dnmoObjects].rightEdge - lastSplit) * voxelH + 2 * voxelD * voxelH))) / voxelSA;

if(lastCost < minCost)
{
    minCost = lastCost;
    splitLoc = lastSplit;
    minLeftCounter = lastLO;
    minRightCounter = lastRO;
    axis = 0;
}

//---------------------------------------------------------------------------------------------
//Repeat for y axis
splitIndex = 1;
lastCost = nObjects * voxelH;
lastSplit = yLeft[1].rightEdge;
leftCount = yLeft[1].objectBoundCounter;
rightCount = nObjects - yRight[1].objectBoundCounter;
lastLO = 0;
lastRO = nObjects;
//Keep looping while cost is decreasing
while(splitIndex < dnObjects)
{
    tempCost = leftCount * (yLeft[splitIndex].rightEdge - yLeft[0].rightEdge) + rightCount * (yLeft[dnmoObjects].rightEdge - yLeft[splitIndex].rightEdge);
    if(tempCost < lastCost)
    {
        lastCost = tempCost;
        lastSplit = yLeft[splitIndex].rightEdge;
        lastLO = leftCount;
        lastRO = rightCount;
    }

    //Update counters
    splitIndex++;
    leftCount += yLeft[splitIndex].objectBoundCounter;
    rightCount -= yRight[splitIndex].objectBoundCounter;
}

//Calculate full SAH cost
lastCost = ((lastLO * (2 * (lastSplit - yLeft[0].rightEdge) * voxelD + 2 * (lastSplit - yLeft[0].rightEdge) * voxelL + 2 * voxelD * voxelL)) + (lastRO * (2 * (yLeft[dnmoObjects].rightEdge - lastSplit) * voxelD + 2 * (yLeft[dnmoObjects].rightEdge - lastSplit) * voxelL + 2 * voxelD * voxelL))) / voxelSA;

if(lastCost < minCost)
{
    minCost = lastCost;
    splitLoc = lastSplit;
    minLeftCounter = lastLO;
    minRightCounter = lastRO;
    axis = 1;
}

//---------------------------------------------------------------------------------------------
//Repeat for z axis
splitIndex = 1;
lastCost = nObjects * voxelD;
lastSplit = zLeft[1].rightEdge;
leftCount = zLeft[1].objectBoundCounter;
rightCount = nObjects - zRight[1].objectBoundCounter;
lastLO = 0;
lastRO = nObjects;
//Keep looping while cost is decreasing
while(splitIndex < dnObjects)
{
    tempCost = leftCount * (zLeft[splitIndex].rightEdge - zLeft[0].rightEdge) + rightCount * (zLeft[dnmoObjects].rightEdge - zLeft[splitIndex].rightEdge);
    if(tempCost < lastCost)
    {
        lastCost = tempCost;
        lastSplit = zLeft[splitIndex].rightEdge;
        lastLO = leftCount;
        lastRO = rightCount;
    }

    //Update counters
    splitIndex++;
    leftCount += zLeft[splitIndex].objectBoundCounter;
    rightCount -= zRight[splitIndex].objectBoundCounter;
}

//Calculate full SAH cost
lastCost = ((lastLO * (2 * (lastSplit - zLeft[0].rightEdge) * voxelL + 2 * (lastSplit - zLeft[0].rightEdge) * voxelH + 2 * voxelH * voxelL)) + (lastRO * (2 * (zLeft[dnmoObjects].rightEdge - lastSplit) * voxelL + 2 * (zLeft[dnmoObjects].rightEdge - lastSplit) * voxelH + 2 * voxelH * voxelL))) / voxelSA;

if(lastCost < minCost)
{
    minCost = lastCost;
    splitLoc = lastSplit;
    minLeftCounter = lastLO;
    minRightCounter = lastRO;
    axis = 2;
}

//Free bin memory
free(xLeft);
free(xRight);
free(yLeft);
free(yRight);
free(zLeft);
free(zRight);

//---------------------------------------------------------------------------------------------
//Make sure a split is in our best interest
if(axis == -1)
{
    //If not decrement the node counter
    nodeIndex--;
    BuildBranch(-1, objs, nObjects);

    return;
}

//Allocate space for left and right lists
Mailbox** leftList = (Mailbox**)malloc(minLeftCounter * sizeof(void*));
Mailbox** rightList = (Mailbox**)malloc(minRightCounter * sizeof(void*));

//Sort objects into lists of those to the left and right of the split plane
int leftIndex = 0, rightIndex = 0;
leftCount = 0;
rightCount = 0;
switch(axis)
{
case 0:
    for(int i = 0; i < nObjects; i++)
    {
        //Get object bounding box
        objs[i]->prim->MakeBoundingBox(tempBox);

        //Add to left and right lists when necessary
        if(tempBox->x0 < splitLoc)
        {
            leftList[leftIndex++] = objs[i];
            leftCount++;
        }

        if(tempBox->x1 > splitLoc)
        {
            rightList[rightIndex++] = objs[i];
            rightCount++;
        }
    }
    break;

case 1:
    for(int i = 0; i < nObjects; i++)
    {
        //Get object bounding box
        objs[i]->prim->MakeBoundingBox(tempBox);

        //Add to left and right lists when necessary
        if(tempBox->y0 < splitLoc)
        {
            leftList[leftIndex++] = objs[i];
            leftCount++;
        }

        if(tempBox->y1 > splitLoc)
        {
            rightList[rightIndex++] = objs[i];
            rightCount++;
        }

    }
    break;

case 2:
    for(int i = 0; i < nObjects; i++)
    {
        //Get object bounding box
        objs[i]->prim->MakeBoundingBox(tempBox);

        //Add to left and right lists when necessary
        if(tempBox->z0 < splitLoc)
        {
            leftList[leftIndex++] = objs[i];
            leftCount++;
        }

        if(tempBox->z1 > splitLoc)
        {
            rightList[rightIndex++] = objs[i];
            rightCount++;
        }

    }
    break;
};

//Delete the bounding box
delete tempBox;

//Delete old objects array
free(objs);

//Construct left and right branches
BuildBranch(height - 1, leftList, leftCount);
BuildBranch(height - 1, rightList, rightCount);

//Build this node
tree[thisNodeIndex] = KDTreeNode();
tree[thisNodeIndex].InitializeInterior(axis, splitLoc, nodeIndex - 1);

return;
}

编辑：好吧，我试图用new / delete替换malloc / free，这对速度没有影响。我还发现只有xLeft / xRight数组上的free（）似乎会显着影响执行时间。我能够通过在递归调用之后移动free（）调用来消除这个问题，虽然我不知道为什么这会产生影响，因为我没有看到任何地方在原始位置之后使用这些数组是免费的（）。至于为什么我使用malloc ...这个程序的某些部分使用缓存对齐的内存，所以我一直在使用_aligned_malloc。虽然可能有一种方法可以获得缓存对齐的新方法，但这是我知道的唯一方法。

Answer 1

是否有可能链接到运行时库的调试版本，该版本正在free()执行额外操作，例如使用垃圾值填充内存？当你链接过度激进的内存调试库时，我已经看到了这种行为。您发布的代码看起来并不奇怪。我很想知道如果用std::vector或std::deque替换数组会发生什么。 Vector应该具有与数组非常相似的行为，如果数组很大，Deque实际上可以提高速度，因为内存管理器不必保证连续的空间。

Answer 2

如果你的程序在退出时执行所有free（），那么你也可以跳过这些调用。当您退出应用程序时，将释放整个流程堆。

编辑：----

好了，现在代码已经发布了，在我看来你不仅仅是在退出时自由，所以你一定要试着弄清楚这是一个错误的奇怪症状，还是只是一个代价高昂的实现自由（）。而不是删除free（）调用，而不是执行它们需要多长时间。堆管理器是否真的耗尽整个19秒？

我确实看到多个地方的多个分配具有相同的范围和生命周期。您可以将这些转换为单个malloc /免费调用，但这会使代码变得不那么清晰且难以保持。所以你必须问自己，这20秒的重要性是多少？

Answer 3

可能只是CRT使用的堆管理器的行为。它可能正在更新免费列表或其他一些内部结构来管理内存。

如果您的瓶颈在这里，您可能应该重新检查程序如何分配和使用内存。

Answer 4

看了一下代码后，我想到的一件大事是malloc(...)，new(...)，delete(...)，free(...)

的混合

BoundingBox* tempBox = new BoundingBox();
// ....
//Delete the bounding box
delete tempBox;

但在其他地方你有

Bin* xLeft = (Bin*)malloc(dnObjects * sizeof(Bin));
// ....
free(xMins);

简而言之，您正在调用C ++的运行时调用new(...)和delete(...)与malloc(...)和free(...)。毕竟，这是在C ++中，所以一个问题为了你...

为什么在本C ++代码中使用来自C的malloc(...)和free(...)？我在这里可以看到的反响是，在OOP范例方面，C ++运行时在使用内存分配方面与C不同。

说完这个，你最好的选择是：

将malloc的所有来电替换为new。
将free的所有来电替换为delete。

重新运行程序，看看是否有所不同。你能证实一下吗？

希望这有帮助，最好的祝福，汤姆。

Answer 5

+1来malloc / free让我的眼睛受到C ++的伤害。忽略这一点并查看代码，有三个想法：

将malloc调用汇总到一个大型malloc并释放（对于x / y / left / right / etc结构）而不是12.将指针设置为适当的大缓冲区。
< / LI>
还在谈论x / y /左/右变量：使用一个基于小堆栈的缓冲区，可以在对象数量很少时使用。当对象数量很大时，则动态分配。如果不是，只需将指针设置为本地堆栈缓冲区。对于小输入，这可以避免动态内存管理。
现在，您的“对象”列表会随每次递归调用（!!）动态分配，释放和重新分配。由于所有权不明确，这令人困惑;但这也是一个性能问题。考虑重新编写代码，以便使用一个“对象”列表。

Answer 6

当您使用new分配时，C ++会存储一些额外的信息，如对象的类型或字符数（如果是数组）等。如果您使用的是免费的，那么它可能是一个碎片问题，您实际上只是在删除中间的数据块但不释放新存储的实际信息。只是一个想法。

Answer 7

当您破坏堆时，它通常变得非常慢。尝试使用运行时的调试版本在调试模式下运行它。

Answer 8

可能是您的代码的参考位置不佳。例如，我看到以下内容：

//Allocate memory for split options
float* xMins = (float*)malloc(nObjects * sizeof(float));
float* yMins = (float*)malloc(nObjects * sizeof(float));
float* zMins = (float*)malloc(nObjects * sizeof(float));
float* xMaxs = (float*)malloc(nObjects * sizeof(float));
float* yMaxs = (float*)malloc(nObjects * sizeof(float));
float* zMaxs = (float*)malloc(nObjects * sizeof(float));
...
free(xMins);
free(xMaxs);
free(yMins);
free(yMaxs);
free(zMins);
free(zMaxs);

现在，假设分配基本上是线性的，那么free(xMaxs);可能需要取消引用从xMins分配了一定数量页面的内存（在free(xMins);期间刚被解除引用），因此您可能需要交换后备存储中的页面才能执行free（这会导致执行时执行速度大幅下降）。重新排序free()以匹配分配顺序可能会有所帮助......在这种情况下，这意味着

free(xMins);
free(yMins);
free(zMins);
free(xMaxs);
free(yMaxs);
free(zMaxs);

Answer 9

听起来您正在从Windows中的调试器运行程序，默认情况下会导致使用特殊的调试堆，这会大大减慢内存释放速度。这甚至适用于非调试版本，只要它们是从调试器（例如Visual Studio）启动的。您应该能够通过在运行程序之前设置环境变量_NO_DEBUG_HEAP=1来禁用此行为（我建议在项目配置设置中而不是在系统设置中设置它，如果可能的话）。

然而，您没有在原始问题中描述有关您的编程环境的任何内容，因此我不得不对其进行某些可能错误的假设。例如，如果您没有在Windows下运行程序，那么我的答案不适用，我不知道您的问题可能是什么原因。

为什么free（）会阻止我的程序？

9 个答案: