Question

此代码适用于n = 10,000但在具有2GB RAM的机器上n = 100,000。 kswap0在1GB内存的机器上被调用n = 10,000但是在n = 100,000时立即显示出分段错误。

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int **createMatrix(int n)
{
    int **mat=(int**)malloc(n*sizeof(int*));
    int i;
    for(i=0;i<n;i++)
    {
        mat[i]=(int*)malloc(n*sizeof(int));
    }
    return mat;
}
void display(int **mat, int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            printf("%d\t",mat[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int n=100000;
    int **matrixOne=createMatrix(n);
    int **matrixTwo=createMatrix(n);
    int **resultantMatrix=createMatrix(n);
    srand(time(NULL));
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            matrixOne[i][j]=rand()%10;
            matrixTwo[i][j]=rand()%10;
        }
    }
    display(matrixOne,n);
    display(matrixTwo,n);
    int k;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            for(k=0;k<n;k++)
            {
                resultantMatrix[i][j]+=matrixOne[i][k]*matrixTwo[k][j];
            }
        }
    }
    display(resultantMatrix,n);
    for(i=0;i<n;i++)
    {
        free(matrixOne[i]);
        free(matrixTwo[i]);
        free(resultantMatrix[i]);
    }

提前谢谢！

Answer 1

int是4个字节。在createMatrix中，忽略第一个malloc，你要分配n * n * sizeof（int）字节。对于n = 100,000，这是40,000,000,000字节，或大约40 GB。由于你这样做了3次，你需要大约120 GB的RAM，而你却没有。对于n = 10,000，您只需要大约1.2 GB（包括交换空间）。

正如提到的注释，你应该检查malloc的结果以获得更清晰的错误信息，并避免seg错误。

Answer 2

我无法分配内存，因为矩阵对我的RAM来说太大了。每次检查malloc的结果

int **createMatrix(int n) {
    int **mat = NULL;
    int i;

    mat = malloc(n*sizeof(int*));
    if (mat == NULL) {
        exit(1);
    }
    for (i = 0; i<n; i++) {
        mat[i] = malloc(n*sizeof(int));
        if (mat[i] == NULL) {
            exit(2);
        }
    }
    return mat;
}

Answer 3

这种方法对于内存使用并不是最佳的，因为您使用的RAM多于必要的RAM。您将矩阵创建为数组数组，因此对于您分配的每一行，都会产生内存开销：

您分配的第一个1D数组不包含数据，但包含指针。
C运行时库将创建堆元数据

虽然这很好，因为你可以像静态二维数组那样编写M [i] [j]，但是与传统的一维主列或列主要数组相比，你的分配（和解除分配）也会慢得多。索引：

//allocation:
int * M = malloc(nCol * nRow * sizeof(int));

//access:
M[i + nRow*j] = data; // Column major
M[i*nCol + j] = data; // Row major

//deallocation:
free(M);

http://en.wikipedia.org/wiki/Row-major_order

最后，数据访问意味着双重取消引用可能比行主要或列主要索引更慢。

二维阵列动态分配中的分段故障

3 个答案: