MexFile 导致“检测到断言”错误 - mexfiles 中的 memcpy 出现问题？

Question

不幸的是，这个问题很狭窄，但我不知所措。

我有一个自定义 mex 文件，它采用两个 uint32 列表，每个列表都已排序且不包含公共条目，并返回一个包含两个列表中所有条目的排序列表。代码是：

#include "mex.h"
#include "matrix.h"
#include "string.h"

#define MIN(x, y) (((x) < (y)) ? (x) : (y))

void CalculationRoutine(uint32_T* CombinedList, const mwIndex FirstNumels, uint32_T* FirstList, const mwIndex SecondNumels, uint32_T* SecondList) {
mwIndex OutCounter = 0, FirstCounter = 0, SecondCounter = 0;
unsigned int i;

// Short-circuit if there is no ovelap.
if (*FirstList > *(SecondList+SecondNumels-1)) {
    memcpy(CombinedList,SecondList,SecondNumels*sizeof(uint32_T));
    memcpy(CombinedList+SecondNumels,FirstList,FirstNumels*sizeof(uint32_T));
    return;
} else if (*SecondList > *(FirstList+FirstNumels-1)) {
    memcpy(CombinedList,FirstList,FirstNumels*sizeof(uint32_T));
    memcpy(CombinedList+FirstNumels,SecondList,SecondNumels*sizeof(uint32_T));
    return;
}

// These can be done with no exhaustion checking. Leave one item because we
// are doing post-checking in the second loop.
for (i=MIN(FirstNumels, SecondNumels)-1; i--;) {
    if (*(FirstList+FirstCounter) < *(SecondList + SecondCounter)) {
        *(CombinedList+OutCounter) = *(FirstList+FirstCounter);        
        FirstCounter++;
    } else {
        *(CombinedList+OutCounter) = *(SecondList+SecondCounter);        
        SecondCounter++;
    }
    OutCounter++;
}

// These ones need exhaustion checking.
while (1){
    if (*(FirstList+FirstCounter) < *(SecondList + SecondCounter)) {
        *(CombinedList+OutCounter) = *(FirstList+FirstCounter);        
        FirstCounter++;
        if (FirstCounter == FirstNumels) {
            // Just copy the rest of the second list.
            memcpy(CombinedList+OutCounter+1,SecondList+SecondCounter,(SecondNumels-SecondCounter+1)*sizeof(uint32_T));
            return;
        }
    } else {
        *(CombinedList+OutCounter) = *(SecondList+SecondCounter);        
        SecondCounter++;
        if (SecondCounter == SecondNumels) {
            // Just copy the rest of the first list.
            memcpy(CombinedList+OutCounter+1,FirstList+FirstCounter,(FirstNumels-FirstCounter+1)*sizeof(uint32_T));
            return;
        }
    }
    OutCounter++;
}
}

void mexFunction( int nlhs, mxArray *plhs[],
                  int nrhs, const mxArray *prhs[] ) {

mxArray *CombinedList = NULL;
uint32_T *FirstList, *SecondList;    
mwIndex FirstNumels = mxGetNumberOfElements(prhs[0]), SecondNumels  = mxGetNumberOfElements(prhs[1]);   

//Input Checking
if (!mxIsUint32(prhs[0])) {
        mexErrMsgTxt("FirstList must be matrix of uint32.");
}
if (!mxIsUint32(prhs[1])) {
        mexErrMsgTxt("SecondList must be a matrix of uint32.");
}

CombinedList = mxCreateNumericMatrix(FirstNumels+SecondNumels, 1, mxUINT32_CLASS, mxREAL);
if (CombinedList == NULL) {
    mexErrMsgTxt("SecondList must be a matrix of uint32.");
}

//Short circuit when we have one or the other inputs empty.
if (mxIsEmpty(prhs[0])){
    if (!mxIsEmpty(prhs[1])) {
        // Return the SecondList verbatim.
        //CopyOneInput(mxGetData(CombinedList),SecondNumels, mxGetData(prhs[1]));
        memcpy(mxGetData(CombinedList), mxGetData(prhs[1]),SecondNumels*sizeof(uint32_T));
    }
    plhs[0] = CombinedList;
    return;
} else if (mxIsEmpty(prhs[1])) {
    // Return the FirstList verbatim.
    //CopyOneInput(mxGetData(CombinedList),FirstNumels, mxGetData(prhs[0]));
    memcpy(mxGetData(CombinedList), mxGetData(prhs[0]),FirstNumels*sizeof(uint32_T));
    plhs[0] = CombinedList;
    return;
}

CalculationRoutine(mxGetData(CombinedList),FirstNumels,
    mxGetData(prhs[0]),SecondNumels,mxGetData(prhs[1]));

plhs[0] = CombinedList;
}

当我运行调用 mex 文件的代码时，我收到断言检测到的错误（例如 Found Corrupted block 381 in table 5. (invalid table index). ）。断言总是会出现，但不一定出现在同一个地方。

如果我恢复到旧版本的代码，就没有问题。所以有些东西正在破坏记忆，但我看不到它。我所做的更改之一是使用 memcpy，但看不出有什么问题。

再次，我很抱歉这是一个如此狭窄的问题，但我们将不胜感激。

更新：肯定是 memcpy 导致了断言。如果我恢复在循环中赋值，断言就会停止。在 mex 文件中使用 memcpy 有限制吗？

Answer 1

我重写了 CalculationRoutine 函数，如下所示：

// merge two sorted lists
void CalculationRoutine(uint32_T* C, const mwIndex nA, uint32_T* A, 
           const mwIndex nB, uint32_T* B)
{
    mwIndex indC = 0, indA = 0, indB = 0;

    // Short-circuit if there is no ovelap.
    if ( A[0] > B[nB-1] ) {
        memcpy(C, B, nB*sizeof(uint32_T));      // copy B
        memcpy(C+nB, A, nA*sizeof(uint32_T));   // copy A
        return;
    } else if ( B[0] > A[nA-1] ) {
        memcpy(C, A, nA*sizeof(uint32_T));      // copy A
        memcpy(C+nA, B, nB*sizeof(uint32_T));   // copy B
        return;
    }

    // loop until one of the two lists is exhausted
    while( indA < nA && indB < nB ) {
        if( A[indA] < B[indB] ) {
            C[indC++] = A[indA++];
        } else {
            C[indC++] = B[indB++];
        }
    }
    // process remaining items in the smaller list
    //if( indA < nA ) memcpy(C+indC, A+indA, (nA-indA)*sizeof(uint32_T));
    //if( indB < nB ) memcpy(C+indC, B+indB, (nB-indB)*sizeof(uint32_T));
    while( indA < nA ) C[indC++] = A[indA++];
    while( indB < nB ) C[indC++] = B[indB++];
}

以下是我测试其正确性/性能的方法：

numIter = 1000; numX = 250; numY = 1000;
x = sort(randi(intmax('uint32'), [250 numIter],'uint32'));
y = sort(randi(intmax('uint32'), [1000 numIter],'uint32'));
M1 = zeros(size(x,1)+size(y,1),numIter,'uint32');
M2 = zeros(size(x,1)+size(y,1),numIter,'uint32');

tic
for i=1:numIter
    M1(:,i) = mySort(x(:,i),y(:,i));
end
toc

tic
for i=1:numIter
    M2(:,i) = sort([x(:,i);y(:,i)]);
end
toc

assert( isequal(M1,M2) )

计时为：

Elapsed time is 0.029080 seconds.        # mySort
Elapsed time is 0.074132 seconds.        # sort

Answer 2

这是 memcpy 的第三个参数中的一个差一错误。 while 循环应该是：

while (1){
    if (*(FirstList+FirstCounter) < *(SecondList + SecondCounter)) {
        *(CombinedList+OutCounter++) = *(FirstList+FirstCounter++);
        if (FirstCounter == FirstNumels) {
            // Just copy the rest of the second list.
            memcpy(CombinedList+OutCounter,SecondList+SecondCounter,(SecondNumels-SecondCounter)*sizeof(uint32_T));
            return;
        }
    } else {
        *(CombinedList+OutCounter++) = *(SecondList+SecondCounter++); 
        if (SecondCounter == SecondNumels) {
            // Just copy the rest of the first list.
            memcpy(CombinedList+OutCounter,FirstList+FirstCounter,(FirstNumels-FirstCounter)*sizeof(uint32_T));
            return;
        }
    }
}