树算法中内存的动态分配和重新分配

Question

I am programming a tree algorithm for simulations. Every processor has its own tree. At a specific point in the program I have to check if there are particles in a specific tree which do not belong there. I collect them and send them to the right tree / processor.

My question is about the process where I collect the particles and put them into lists of dynamic size. Since the number of particles I have to send to another tree is not constant, I have to work with dynamic arrays.

I implemented a small program where all this should happen. But it works only for small N . But also for small N there are sometimes errors. The reallocation process does probably not work.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define DIM 2

// Struct for particles
typedef struct {
    double m;
    double x[DIM];
    int id;
} Particle;

// Structs for lists I want to fill with particle data
typedef struct {
    double **list; // every processor has its own list
    int *counter; // length of the list
} ParticleList;

void generateParticles(Particle *p, int N);
void buildList(Particle *p, ParticleList *plist, int numprocs, int N);

int main() {
    time_t t;
    srand((unsigned)time(&t));

    // Generate and print data
    int N = 3;
    Particle *p = (Particle*)malloc(N * sizeof(*p));
    generateParticles(p, N);

    for (int i = 0; i < N; i++) {
        printf("id: %d m: %lf x: %lf %lf\n", p[i].id, p[i].m, p[i].x[0], p[i].x[1]);
    }

    // Fill lists
    int numprocs = 4;
    ParticleList plist;
    plist.list = malloc(sizeof(double*) * numprocs);
    // At the beginning every list should be of size zero
    // Therefore I initialize lists for every processor of size zero
    for (int k = 0; k < numprocs; k++)
        plist.list[k] = malloc(sizeof(double) * 0);
    plist.counter = calloc(numprocs, sizeof(int));
    // Fill the lists randomly
    buildList(p, &plist, numprocs, N);

    for (int k = 0; k < numprocs; k++) {
        printf("%d\n", plist.counter[k]);
        for (int c = 0; c < (DIM * plist.counter[k]); c++) {
            printf("%lf ", plist.list[k][c]);
        }
        printf("\n");
    }

    free(p);
    return 0;
}

void buildList(Particle *p, ParticleList *plist, int numprocs, int N) {
    for (int k = 0; k < numprocs; k++) {
        for (int i = 0; i < N; i++) {
            if (rand() % 10 < 3) { // randomly choose particles to fill the list
                plist->counter[k]++;
                // Here might be the problem?
                plist->list[k] = realloc(plist->list[k], DIM * sizeof(plist->list[k]));
                for (int j = plist->counter[k]; j < (plist->counter[k] + DIM); j++)
                    plist->list[k][j] = p[i].x[j];
            }
        }
    }
}

void generateParticles(Particle *p, int N) {
    for (int i = 0; i < N; i++) {
        for (int d = 0; d < DIM; d++) {
            p[i].x[d] = rand() % 10;
        }
        p[i].m = rand() % 10;
        p[i].id = i;
    }
}

The problem is probably in this line: plist->list[k] = realloc(plist->list[k], DIM * sizeof(plist->list[k]));

I get the following error:

*** Error in `./append_struct': realloc(): invalid next size: 0x00000000015df540 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7fc931b3e7e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x834aa)[0x7fc931b4a4aa]
/lib/x86_64-linux-gnu/libc.so.6(realloc+0x179)[0x7fc931b4b839]
./append_struct[0x400b5e]
./append_struct[0x4009bf]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7fc931ae7830]
./append_struct[0x4007b9]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:02 3670408                            /home/exp/append_struct
00601000-00602000 r--p 00001000 08:02 3670408                            /home/exp/append_struct
00602000-00603000 rw-p 00002000 08:02 3670408                            /home/exp/append_struct
015df000-01600000 rw-p 00000000 00:00 0                                  [heap]
7fc92c000000-7fc92c021000 rw-p 00000000 00:00 0 
7fc92c021000-7fc930000000 ---p 00000000 00:00 0 
7fc9318b1000-7fc9318c7000 r-xp 00000000 08:02 4985364                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7fc9318c7000-7fc931ac6000 ---p 00016000 08:02 4985364                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7fc931ac6000-7fc931ac7000 rw-p 00015000 08:02 4985364                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7fc931ac7000-7fc931c87000 r-xp 00000000 08:02 4994073                    /lib/x86_64-linux-gnu/libc-2.23.so
7fc931c87000-7fc931e87000 ---p 001c0000 08:02 4994073                    /lib/x86_64-linux-gnu/libc-2.23.so
7fc931e87000-7fc931e8b000 r--p 001c0000 08:02 4994073                    /lib/x86_64-linux-gnu/libc-2.23.so
7fc931e8b000-7fc931e8d000 rw-p 001c4000 08:02 4994073                    /lib/x86_64-linux-gnu/libc-2.23.so
7fc931e8d000-7fc931e91000 rw-p 00000000 00:00 0 
7fc931e91000-7fc931ea9000 r-xp 00000000 08:02 4994056                    /lib/x86_64-linux-gnu/libpthread-2.23.so
7fc931ea9000-7fc9320a8000 ---p 00018000 08:02 4994056                    /lib/x86_64-linux-gnu/libpthread-2.23.so
7fc9320a8000-7fc9320a9000 r--p 00017000 08:02 4994056                    /lib/x86_64-linux-gnu/libpthread-2.23.so
7fc9320a9000-7fc9320aa000 rw-p 00018000 08:02 4994056                    /lib/x86_64-linux-gnu/libpthread-2.23.so
7fc9320aa000-7fc9320ae000 rw-p 00000000 00:00 0 
7fc9320ae000-7fc9320d4000 r-xp 00000000 08:02 4994051                    /lib/x86_64-linux-gnu/ld-2.23.so
7fc9322b5000-7fc9322b8000 rw-p 00000000 00:00 0 
7fc9322d0000-7fc9322d3000 rw-p 00000000 00:00 0 
7fc9322d3000-7fc9322d4000 r--p 00025000 08:02 4994051                    /lib/x86_64-linux-gnu/ld-2.23.so
7fc9322d4000-7fc9322d5000 rw-p 00026000 08:02 4994051                    /lib/x86_64-linux-gnu/ld-2.23.so
7fc9322d5000-7fc9322d6000 rw-p 00000000 00:00 0 
7ffc92bdb000-7ffc92bfc000 rw-p 00000000 00:00 0                          [stack]
7ffc92bfc000-7ffc92bfe000 r--p 00000000 00:00 0                          [vvar]
7ffc92bfe000-7ffc92c00000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Aborted (core dumped)

Edit:

My example code is just a rough sketch and I consider myself as a beginner in C. This is probably the reason why my question is not really clear. In my actual code I am building a tree structure with my particles (Quadtree in 2D and Octree in 3D) on every processor. Every processor has other particles. I identify wrong particles using their position within the tree in a recursive tree walk and send them to other processors since I want compact tree structures. In order to do that I have to put wrong particles into a list which I can then pass to the MPI library in order to send the data to other processors. The number of particles is normally much larger than the number of processors (N >> numProc).

Answer 1

I don't quite get your reasoning, it would maybe work for optimizing computation speed, but you'd need to have a working program to contemplate doing that.

Also, your algorithm for distributing particles to processors doesn't work. As it is written, particles have a 70% chance of not being allocated to any list.

In your declaration for the list of particles:

typedef struct {
    double **list; // a list of double* ?  It's going to be hard to find which double
                   // belongs to which Particle, this makes your app more confusing
                   // and much harder to write than it ought to.
    int *counter;  // a length of lengths?  what's its length?
} ParticleList;

You should consider doing something like this instead. This would probably work better, I've omitted error-checking on the result of calloc(), which you should always do. I've chosen calloc(), because it clears the memory it allocates.

typedef struct {
  struct Particle* next;
  double m;
  double x[DIM];
  int id;
} Particle;

typedef struct Particle* ParticleList;

// this should look familiar to you.
void insert_particle(ParticleList* list, struct Particle* part)
{
  part->next = NULL;  // just to make sure we don't introduce bugs here
  if (*list == NULL)
  {
    *list = part;
    return;
  }
  struct Particle* p = *list;
  while (p)
  {
    if (p->next == NULL)
    {
      p->next = part
      return;
    }
    p = p->next;
  }
}

int main()
{
   int i;
   int numProcs = 4;
   int assigned_proc;
   int N = 3;  // less particles than threads?  This does not sound right...
   // ...
   // allocate empty lists and all particles.
   ParticleList* procparts = calloc(numprocs, sizeof(ParticleList));
   struct Particle* particles = calloc(N, sizeof(struct Particle));

   for (i = 0; i < N; ++i)                        // for each particle ...
   {
     // initialize particle location...
     particles[i].id = i;
     // ... and x[]...

     assigned_proc = rand() % numprocs;           // pick a processor...

     insert_particle(&procparts[assigned_proc], &particles[i]);
   }

   // ...
}

Note that this implementation does not require any call to realloc() during execution.

Once your app works using 'normal' threads, it will be much simpler to make it MPI compatible.