C gtk+中乘法后的错误和随机结果；3回拨

我已经编写了一个Gtk+3应用程序来分析一些图像。创建文件名列表后，我调用一个函数（通过回调按钮），该函数读取图像并执行一些操作。除了我计算这个4D阵列（大到1GB）外，其他一切都正常工作：

for（int i=0；iList）；
长整数Npairs=Nimages/2；
TIFF*tif=TIFFOpen（（gchar*）g_slist_nth_数据（plist->List，1），“r”）；
uint32长度；
uint32宽度；
t尺寸t扫描线；
tdata_t bufA；
tdata_t bufB；
uint16*dataA；
uint16*数据；
int-csiMax；
int-psiMax；
int行；
int col；
TIFFGetField（tif、TIFFTAG_图像长度和长度）；
TIFFGetField（tif、TIFFTAG_图像宽度和宽度）；
TIFFClose（tif）；
g_打印（“长度%d像素”，长度）；
g_打印（“宽度%d像素\n”，宽度）；
扫描线=TIFF扫描线尺寸（tif）；
bufA=_TIFFmalloc（扫描线）；
bufB=_TIFFmalloc（扫描线）；
g_print（“-----------------------------------\n”）；
plist->Am=（双**）malloc（长度*尺寸（双*）；
plist->Bm=（双**）malloc（长度*尺寸（双*）；
plist->SA=（双**）malloc（长度*尺寸（双*）；
plist->SB=（双**）malloc（长度*尺寸（双*）；
plist->A=（uint16**）malloc（长度*尺寸（uint16*）；
plist->B=（uint16**）malloc（长度*尺寸（uint16*）；
plist->u=（双**）malloc（长度*尺寸（双*）；
plist->v=（双**）malloc（长度*尺寸（双*）；
对于（row=0；rowu[row]=（double*）malloc（width*sizeof（double））；
plist->v[行]=（双*）malloc（宽度*尺寸（双））；
plist->Am[行]=（双*）malloc（宽度*尺寸（双））；
plist->Bm[行]=（双*）malloc（宽度*大小（双））；
plist->SA[行]=（双*）malloc（宽度*尺寸（双））；
plist->SB[行]=（双*）malloc（宽度*尺寸（双））；
plist->A[行]=（uint16*）malloc（扫描线）；
plist->B[行]=（uint16*）malloc（扫描线）；
}
/*这里我省略了我计算Am，Bm，SA，SB的部分，因为它是正确的*/
Memorystaturex statex；
statex.dwLength=sizeof（statex）；
GlobalMemoryStatusEx（&statex）；
双免记忆；
memfree=（双）statex.ullAvailPhys；
csiMax=plist->dtop+plist->ddown+1；
psiMax=plist->dleft+plist->dright+1；
双maxram=ceil（memfree*plist->Kmem）；
double maxArraySize=maxram/（csiMax*psiMax*sizeof（double）*宽度）；
双阶梯R=长度/最大阵列尺寸；
stepR=细胞（stepR）；
long int row_step=ceil（长度/步长）；
int*forstep=（int*）malloc（长度*sizeof（int））；
forstep[0]=0；
长整型假人；
长整型k=0；
对于（row=1；rowdtop][col+plist->dleft]=（dataB[col]-plist->Bm[row][col]）/（plist->SB[row][col]）；
}
}
TIFFClose（tifA）；
TIFFClose（tifB）；
/*calcolo di C[x][y][r][C]*/
对于（行=0；行<行\步；行++）{
用于（列=0；列<宽度；列++）{
对于（int x=0；x

编辑2

---

正如您所看到的，每次我执行程序时，结果是不同的，这些零元素的位置也不同。

像这些随机错误在大多数情况下都是典型C内存错误的症状

我建议您使用valgrind调试您的软件，并搜索任何意外的内存访问（错误的指针解引用、内存泄漏、坏内存释放等）

你可以找到一本好的教程

例如，使用

libtool--mode=executevalgrind
for(int i=0; i<Nimages; i=i+2){
        TIFF* tifA = TIFFOpen(impath[i], "r");
        TIFF* tifB = TIFFOpen(impath[i+1], "r");

        for (row = 0; row < length; row++){
            TIFFReadScanline(tifA, bufA, row,0);
            TIFFReadScanline(tifB, bufB, row,0);
            dataA=bufA;
            dataB=bufB;
            for(col = 0; col < width; col++){
                A[row][col] = dataA[col];
                B[row][col] = dataB[col];
            }
        }
        TIFFClose(tifA);
        TIFFClose(tifB); 
       for (row = 0; row < length; row++){
           for (col = 0; col < width; col++){
               for ( int x = 0 ; x < csiMax ; x++ ) {
                    for ( int y = 0 ; y < psiMax ; y++ ){
                        C[row][col][x][y] += A[row][col]*B[row+x][col+y];
                       }
                   }
               }
           }
       }

        gdouble ****alloc4D ( gint maxx, gint maxy,gint maxr,gint maxc ) {
            gdouble *rows = g_malloc0(maxx*maxy*maxr*maxc*sizeof(*rows));
            gdouble **cols = g_malloc0(maxx*maxy*maxr*sizeof(*cols));
            gdouble ***mat = g_malloc0(maxx*maxy*sizeof(*mat));
            gdouble ****result = g_malloc0(maxx*sizeof(*result));
            for ( int x = 0 ; x < maxx ; x++ ) {
                result[x] = mat;
                mat += maxy;
                for ( int y = 0 ; y < maxy ; y++ ) {
                    result[x][y] = cols ;
                    cols += maxr;
                    for ( int r = 0 ; r < maxr ; r++ ) {
                        result[x][y][r] = rows;
                        rows += maxc;
                    }
                }
            }
            return result;
        }

        void free4D(gdouble ****Mat4D){
              g_free(Mat4D[0][0][0]);
              g_free(Mat4D[0][0]);
              g_free(Mat4D[0]);
              g_free(Mat4D);
        }

void TIFFanalyzePairs(GtkWidget *widget, gpointer   data){
    MYlist *plist=data;
        long int Nimages=g_slist_length( plist->List);
        long int Npairs=Nimages/2;

        TIFF* tif = TIFFOpen((gchar*)g_slist_nth_data(plist->List,1), "r");
        uint32 length;
        uint32 width;
        tsize_t scanline;
        tdata_t bufA;
        tdata_t bufB;
        uint16 *dataA;
        uint16 *dataB;
        int csiMax;
        int psiMax;
        int row;
        int col;
        TIFFGetField(tif, TIFFTAG_IMAGELENGTH,&length);
        TIFFGetField(tif, TIFFTAG_IMAGEWIDTH,&width);
        TIFFClose(tif);
        g_print("length %d pixel \n",length);
        g_print("width  %d pixel \n",width);

        scanline = TIFFScanlineSize(tif);
        bufA = _TIFFmalloc(scanline);
        bufB = _TIFFmalloc(scanline);

        g_print("--------------------------\n");

        plist->Am=(double**)malloc(length*sizeof(double*));
        plist->Bm=(double**)malloc(length*sizeof(double*));
        plist->SA=(double**)malloc(length*sizeof(double*));
        plist->SB=(double**)malloc(length*sizeof(double*));
        plist->A=(uint16**)malloc(length*sizeof(uint16*));
        plist->B=(uint16**)malloc(length*sizeof(uint16*));
        plist->u=(double**)malloc(length*sizeof(double*));
        plist->v=(double**)malloc(length*sizeof(double*));

        for(row=0; row<length; row++){
            plist->u[row]=(double*)malloc(width*sizeof(double));
            plist->v[row]=(double*)malloc(width*sizeof(double));
            plist->Am[row]=(double*)malloc(width*sizeof(double));
            plist->Bm[row]=(double*)malloc(width*sizeof(double));
            plist->SA[row]=(double*)malloc(width*sizeof(double));
            plist->SB[row]=(double*)malloc(width*sizeof(double));
            plist->A[row]=(uint16*)malloc(scanline);
            plist->B[row]=(uint16*)malloc(scanline);

        }
/* HERE I OMITTED THE SECTION WHERE I COMPUTE Am, Bm, SA, SB BECAUSE IT'S RIGHT*/


        MEMORYSTATUSEX statex;

        statex.dwLength = sizeof (statex);
        GlobalMemoryStatusEx (&statex);
        double memfree;
        memfree=(double)statex.ullAvailPhys;

        csiMax=plist->dtop+plist->ddown+1;
        psiMax=plist->dleft+plist->dright+1;

        double maxram=ceil(memfree*plist->Kmem);
        double maxArraySize=maxram/(csiMax*psiMax*sizeof(double)*width);
        double stepR=length/maxArraySize;
        stepR=ceil(stepR);
        long int row_step=ceil(length/stepR);
        int *forstep=(int*)malloc(length*sizeof(int));

        forstep[0]=0;
        long int dummy;
        long int k=0;
        for(row=1; row<length; row++){
            dummy=(row+1)%row_step;
            if(dummy==0){
                k=k+1;
                forstep[k]=row;
            }
        }
        if(forstep[k]!=length-1){
            forstep[k+1]=length-1;
            k=k+1;
        }
        g_print("rowstep %ld pixel\n", row_step);
        for(int l=0; l<=k;l++){
            g_print("l=%d ->row=%d \n", l,forstep[l]);
        }

        gdouble **A=(gdouble**)g_malloc(length*sizeof(double*));
        for(row=0; row<length; row++){
            A[row]=(gdouble*)g_malloc(width*sizeof(gdouble));
        }
        gdouble **Bneg;
        Bneg=(gdouble**)g_malloc((csiMax+length)*sizeof(gdouble*));
        for(row=0; row<length+csiMax; row++){
            Bneg[row]=(gdouble*)g_malloc((width+psiMax)*sizeof(gdouble));
    }


        for(row=0; row<length+csiMax; row++){
            for(col=0; col<width+psiMax; col++){
                Bneg[row][col]=  log(-1);
                }
        }

        gint csiNeg=plist->dtop;
        gint psiNeg=plist->dleft;


        for(int step=0; step<k; step++ ){
            gdouble ****C = alloc4D(row_step,width,csiMax,psiMax);

            for(int i=0; i<Nimages-1; i=i+2){
                TIFF* tifA = TIFFOpen((gchar*)g_slist_nth_data(plist->List,i), "r");
                TIFF* tifB = TIFFOpen((gchar*)g_slist_nth_data(plist->List,i+1), "r");

                for (row = 0; row < length; row++){
                    TIFFReadScanline(tifA, bufA, row,0);
                    TIFFReadScanline(tifB, bufB, row,0);
                    dataA=bufA;
                    dataB=bufB;
                    for(col = 0; col < width; col++){
                        A[row][col] = (dataA[col]-plist->Am[row][col])/(plist->SA[row][col]);
                        Bneg[row+plist->dtop][col+plist->dleft] = (dataB[col]-plist->Bm[row][col])/(plist->SB[row][col]);
                    }
                }
                TIFFClose(tifA);
                TIFFClose(tifB); 

                /* calcolo di C[x][y][r][c] */
                for (row = 0; row < row_step; row++){
                    for (col = 0; col < width; col++){
                        for ( int x = 0 ; x < csiMax ; x++ ) {
                            for ( int y = 0 ; y < psiMax ; y++ ){
                                C[row][col][x][y] += A[row+forstep[step]][col]*Bneg[x+row+forstep[step]][y+col];
                                                            }
                        }
                    }
                }

            } 
/* HERE A SECTION THAT DEPENDS ON C[row][col][x][y] , SO I OMITTED BECAUSE THE PROBLEMS START CALCULATING C*/
        free4D(C);
        }

        _TIFFfree(bufA);
        _TIFFfree(bufB);
        free2D(A,length);
        free2D(Bneg,length);

        toc(t0);


    }



    int
    main (int    argc,
          char **argv)
    {
      gtk_init (&argc, &argv);
      GtkWidget *window;
      GtkWidget *grid;
      GdkPixbuf *icon;
      GtkWidget *start_button;
      GtkWidget *select_files_button;
      GtkWidget *button;


      MYlist datalist;
      datalist.dtop=6;//csiNeg
      datalist.dleft=3;//psiNeg
      datalist.ddown=6;//csiPos
      datalist.dright=30;//psiPos
      datalist.Kmem=0.6;


      /* create a new window, and set its title */
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title (GTK_WINDOW (window), "SPEC beta");
      gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
      gtk_window_set_default_size(GTK_WINDOW(window), 900, 700);
      gtk_container_set_border_width (GTK_CONTAINER (window), 15);

      grid = gtk_grid_new ();

      gtk_container_add (GTK_CONTAINER (window), grid);

      start_button = gtk_button_new_with_label ("Start");
      g_signal_connect (start_button, "clicked", G_CALLBACK ( TIFFanalyzePairs), &datalist);
      gtk_grid_attach (GTK_GRID (grid), start_button, 0, 0, 2, 1);

      /* bottone selezione files con annessa finestra di dialogo (callback) */
      select_files_button = gtk_button_new_with_label ("Select files or folder");
      g_signal_connect ( select_files_button, "clicked", G_CALLBACK (select_files), &datalist);
      gtk_grid_attach (GTK_GRID (grid), select_files_button, 0, 1, 2, 1);

      gtk_widget_show_all (window);

      g_signal_connect(window, "destroy",
          G_CALLBACK(gtk_main_quit), NULL);
      g_object_unref(icon);

      gtk_main ();

      return 0;
    }