malloc(): memory corruption

[sukharef]

всем привет!
такой вопрос.
пытаюсь попробовать простой пример кода для функции MPI_Allgatherv на кластере.
В итоге получаю следующую ошибку(и) :
*** glibc detected *** ./main: malloc(): memory corruption: 0x0000000001ee6820 ***
*** glibc detected *** ./main: corrupted double-linked list: 0x0000000001285510 ***

все идет нормально до самой функции, после чего мне приходится прерывать выполнение, потому что все зависает.
идея в том, что каждый поток работает с частью массива arrRandTime. рабочая часть определяется пределами
соседних элементов массива tranfArrayPos. потом, на каком-то шаге, мне нужно объеденить все рабочие части.
заранее спасибо за совет!


код:

#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

using namespace std;

int* malloc1dInitInt(int rows) ;
double* malloc1dInitDouble(int rows);

int main(int argc, char** argv) {
    
    int nprocs, myrank;
    
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
    MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
    
    srand(time(NULL)+myrank);

    int N0 = 100; 
    
    int* tranfArray = malloc1dInitInt(nprocs);
    int* tranfArrayPos = malloc1dInitInt(nprocs);
 
    if (N0 < nprocs) 
       for (int s = 0; s < nprocs; s ++) {
           if ( s < N0) {
               tranfArray [s] = 1; tranfArrayPos[s] = s;
           } else { tranfArray [s] = 0; tranfArrayPos[s] = s;}
       }
    // для nprocs = 16 заполняется нормально 
    if (N0 >= nprocs) {
        
           tranfArrayPos[0] = 0;
           int sum = 0;
           int s = 0;
             
           while ( N0 > ( sum + ceil((double)N0/nprocs) ) ) {
                 tranfArray[s] = ceil((double)N0/nprocs);
                 sum += tranfArray[s] ;
                 s+=1;
                 if (s == nprocs-1) break;
           }
           
           while ( s != (nprocs)) {
                if (s == (nprocs - 1)) {tranfArray[s] = N0-sum;} 
                tranfArray[s] = (N0-sum)/(nprocs-s);
                sum += tranfArray[s];
                s += 1;

           }
            
           sum = tranfArray[0];
           for (int s = 1; s < nprocs; s ++) { tranfArrayPos[s] = sum; sum += tranfArray[s]; }   
    }
    
    double*  arrRandTime = malloc1dInitDouble(N0);
     
    MPI_Allgatherv(&(  arrRandTime[tranfArrayPos[myrank]]), tranfArray[myrank] , MPI_DOUBLE, 
&( arrRandTime[tranfArrayPos[myrank]]), tranfArray, tranfArrayPos, MPI_DOUBLE, MPI_COMM_WORLD);

    MPI_Finalize();
    
    return 0;
}

double* malloc1dInitDouble(int rows) 
{
        
        double* array = (double*)malloc(rows*sizeof(double));
  
        for (int i=0; i < rows; i++) array[i] = 0.0;

        return array;
}

int* malloc1dInitInt(int rows) 
{
        
        int* array = (int*)malloc(rows*sizeof(int));
  
        for (int i=0; i < rows; i++) array[i] = 0;

        return array;
}