docker.txt

docker run --rm -it spagnuolocarmine/docker-mpi

- Per creare il file p.c con il codice:
echo '#include <mpi.h>
#include <stdio.h>
#include <string.h>

...' > p.c

cat <<EOF > nbody_mpi.c
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
...

EOF


- Per compilare il codice di p.c:
mpicc p.c

- Per eseguire il codice di p.c:
mpirun --allow-run-as-root a.out

cat <<EOF > p.c
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>

#define SOFTENING 1e-9f

typedef struct { float x, y, z, vx, vy, vz; } Body;

void randomizeBodies(float *data, int n) {
  for (int i = 0; i < n; i++) {
    data[i] = 2.0f * (rand() / (float)RAND_MAX) - 1.0f;
  }
}

void bodyForce(Body *p, float dt, int n) {
  for (int i = 0; i < n; i++) { 
    float Fx = 0.0f; float Fy = 0.0f; float Fz = 0.0f;

    for (int j = 0; j < n; j++) {
      float dx = p[j].x - p[i].x;
      float dy = p[j].y - p[i].y;
      float dz = p[j].z - p[i].z;
      float distSqr = dx*dx + dy*dy + dz*dz + SOFTENING;
      float invDist = 1.0f / sqrtf(distSqr);
      float invDist3 = invDist * invDist * invDist;

      Fx += dx * invDist3; Fy += dy * invDist3; Fz += dz * invDist3;
    }

    p[i].vx += dt*Fx; p[i].vy += dt*Fy; p[i].vz += dt*Fz;
  }
}

int main(int argc, char** argv) {
  int nBodies = 30000; // Default number of bodies
  if (argc > 1) nBodies = atoi(argv[1]); // Manual definition of # bodies

  const float dt = 0.01f; // Time step
  const int nIters = 10;  // Simulation iterations

  int bytes = nBodies * sizeof(Body);
  Body *p = (Body*)malloc(bytes); // Allocate memory for all bodies

  double totalTime = 0.0;

  // Initialize the MPI environment
  MPI_Init(&argc, &argv);

  // Get the rank and size of the process
  int world_rank, world_size;
  MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
  MPI_Comm_size(MPI_COMM_WORLD, &world_size);

  // Inizializzazione dei corpi nel processo master (rank 0)
  if (world_rank == 0) {
    randomizeBodies((float*)p, 6 * nBodies); // Initialize positions and velocities
  }

  // Broadcast the initialized bodies to all processes
  MPI_Bcast(p, nBodies * sizeof(Body) / sizeof(float), MPI_FLOAT, 0, MPI_COMM_WORLD);

  // Calcola il numero di corpi da elaborare per ciascun processo
  int bodies_per_process = nBodies / world_size;
  int remaining_bodies = nBodies % world_size;

  // Determina il range di corpi per il processo corrente
  int start_body = world_rank * bodies_per_process + (world_rank < remaining_bodies ? world_rank : remaining_bodies);
  int end_body = start_body + bodies_per_process + (world_rank < remaining_bodies ? 1 : 0);
  int local_bodies_count = end_body - start_body;

  // Calcola il numero totale di iterazioni da eseguire su tutti i processi
  int total_iterations = nIters * world_size;

  // Calcola il numero di iterazioni da eseguire per ciascun processo
  int iter_per_process = total_iterations / world_size;
  int remaining_iterations = total_iterations % world_size;

  // Determina il range di iterazioni per il processo corrente
  int start_iter = world_rank * iter_per_process + (world_rank < remaining_iterations ? world_rank : remaining_iterations);
  int end_iter = start_iter + iter_per_process + (world_rank < remaining_iterations ? 1 : 0);

  printf("Rank %d, start_iter: %d, end_iter: %d\n", world_rank, start_iter, end_iter);

  // Iterazioni sui corpi
  for (int iter = start_iter; iter < end_iter; iter++) {
    clock_t start = clock();

    // Each process calculates the forces on its local bodies
    bodyForce(p + start_body, dt, local_bodies_count);

    // Integrate positions for local bodies
    for (int i = start_body; i < end_body; i++) {
      p[i].x += p[i].vx * dt;
      p[i].y += p[i].vy * dt;
      p[i].z += p[i].vz * dt;
    }

    clock_t end = clock();
    double tElapsed = (double)(end - start) / CLOCKS_PER_SEC;
    if (iter > 1) { // La prima iterazione è di riscaldamento
      totalTime += tElapsed; 
    }
#ifndef SHMOO
    printf("Rank %d, Iteration %d: %.3f seconds\n", world_rank, iter, tElapsed);
#endif
  }

  double avgTime;
  MPI_Reduce(&totalTime, &avgTime, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
  avgTime /= world_size;

  if (world_rank == 0) {
#ifdef SHMOO
    printf("%d, %0.3f\n", nBodies, 1e-9 * nBodies * nBodies / avgTime);
#else
    printf("Average rate for iterations 2 through %d: %.3f +- %.3f steps per second.\n",
         nIters, 1.0 / avgTime, avgTime / (nIters - 1));
    printf("%d Bodies: average %0.3f Billion Interactions / second\n", nBodies, 1e-9 * nBodies * nBodies / avgTime);
#endif
  }

  free(p);
  MPI_Finalize();
  return 0;
}
EOF