pc in parallelo

[albatros]

Beh, se elmetal si mette a scrivere software che usi mpi il discorso cambia, anche se tutte le difficoltà e le limitazioni dovute alla rete restano...
A me, anche se le sue intenzioni, come già detto, non mi sembrano molto chiare, mi è parso di capire che cercasse un software che ripartisse l'esecuzione dei normali applicativi su più pc, senza mettersi a parallelizzare il codice di un software specifico o a scriverne uno ex-novo...
Una cosa tipo:"Lancio il programma di editing video e una parte dei calcoli li faccio fare all'altro mio computer distante 50Km oppure eseguo dieci applicativi e un certo software apposito automaticamente ne farà girare 7 su questa macchina e tre sull'altra scegliendo opportunamente quali"...
E' sulla fattibilità e la convenienza di un simile sistema che le mie perplessità crescono come x^6...

P.S.
OpenMP sarà supportato da gcc a partire dalla versione 4.2
Vedi: http://gcc.gnu.org/gcc-4.2/changes.html

[elmetal]

non ho alcun motivo concreto per farlo,lo faccio solo per il gusto di imparare e di ampliare le mie conoscenze,tutto qui

[Simone_R]

non ho alcun motivo concreto per farlo,lo faccio solo per il gusto di imparare e di ampliare le mie conoscenze,tutto qui

Trovato un esempio di MPI:
Risolve con le differenze finite la Heat Equation di poisson in 1D
http://en.wikipedia.org/wiki/Heat_equation

Codice: Seleziona tutto

#include <math.h>
#include <stdio.h>
#include <mpi.h>

//////////////////////////////
//////////////////////////////
int main( int argc , char **argv  ) {

  int i , n ;

  int num , total ;
  int j = 0 ;

  double *Vect ;
  double *result_vect ;

  double l = 0.0 ; // integration domain.
  double r = 1.0 ;

  double bc_l = 0.0 ;
  double bc_r = 1.0 ;

  double delta_t = 0.0001 ;
  double delta_dom ;
  double delta_x ;

  double temp1 , temp2 ;
  int step = 10000 ;

  MPI_Status status;

  const double K = 0.01 ;

  int segment_size = 10 ;
  int total_size ;

  Vect = (double*)calloc( sizeof(double) ,  segment_size ) ;

  MPI_Init( &argc , &argv ) ;
  MPI_Comm_rank( MPI_COMM_WORLD , &num ) ;
  MPI_Comm_size( MPI_COMM_WORLD , &total ) ;

  if ( num == 0 ) printf("total: %d \n" , total ) ;
  printf("num: %d \n" , num ) ;

  delta_dom = ( fabs( r - l )/(double)total ) ;

  total_size = segment_size*num ;

  delta_x = delta_dom / (double)(segment_size - 1) ;

  if ( num == 0 ) {

    // Initial cond ;
    for ( i = 1 ; i < segment_size ; i++  ) {
      Vect[i] = sin( i*delta_x ) ;
    }

    Vect[0] = bc_l ;

  } else if ( num == total-1 ) {
    // Initial cond ;

    for ( i = 0 ; i < segment_size ; i++  ) {
      Vect[i] = sin( (double)num*delta_dom + i*delta_x ) ;
    }

    Vect[segment_size-1] = bc_r ;

  } else {

    // Initial cond ;
    for ( i = 0 ; i < segment_size - 1 ; i++  ) {
      Vect[i] = sin( ((double)num*delta_dom + i*delta_x)*5 ) ;
    }
    Vect[segment_size-1] = bc_r ;
  }


  delta_t = (1.0/5.0) * ( (delta_x*delta_x)/K ) ;

  /////////////////////////////////////////////////////////////
  // Iterations: //////////////////////////////////////////////
  /////////////////////////////////////////////////////////////
  for ( n = 0 ; n < step ; n++ ) {

    temp2 = Vect[0] ;
    for ( i = 1 ; i < segment_size-1 ; i++ ) {
      temp1 = Vect[i] ;
      Vect[i] = temp1 + K/(delta_x*delta_x) * ( Vect[i+1] - 2.0*temp1 + temp2 )*delta_t ;
      temp2 = temp1 ;
    }

    // Exchange the values with other proc.
    if ( num == 0 ) { // if master send only to/from the right procces

      MPI_Send ( &Vect[segment_size-2] , 1 , MPI_DOUBLE , 1 , 99 , MPI_COMM_WORLD ) ;
      MPI_Recv ( &Vect[segment_size-1] , 1 , MPI_DOUBLE , 1 , 99 , MPI_COMM_WORLD , &status  ) ;

    } else if ( num == total - 1 ) {

      if ( num % 2 == 0  ) {   // Last proc send & recive only to/from left proc.

        MPI_Recv( &Vect[0] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD , &status ) ;
        MPI_Send( &Vect[1] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD ) ;

      } else {

        MPI_Send( &Vect[1] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD ) ;
        MPI_Recv( &Vect[0] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD , &status ) ;

      }

    } else { // Intermediate proc. send & recive to/from left and right.

      if ( num % 2 == 0 ) {
        // even procces
        MPI_Recv( &Vect[0] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD , &status ) ;
        MPI_Send( &Vect[1] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD ) ;

        MPI_Recv( &Vect[segment_size-1] , 1 , MPI_DOUBLE , num+1 , 99 , MPI_COMM_WORLD , &status ) ;
        MPI_Send( &Vect[segment_size-2] , 1 , MPI_DOUBLE , num+1 , 99 , MPI_COMM_WORLD ) ;

      } else {
        // odd procces
        MPI_Send( &Vect[1] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD ) ;
        MPI_Recv( &Vect[0] , 1 , MPI_DOUBLE , num-1 , 99 , MPI_COMM_WORLD , &status  ) ;

        MPI_Send( &Vect[segment_size-2] , 1 , MPI_DOUBLE , num+1 , 99 , MPI_COMM_WORLD  ) ;
        MPI_Recv( &Vect[segment_size-1] , 1 , MPI_DOUBLE , num+1 , 99 , MPI_COMM_WORLD , &status  ) ;
      }
    }
  }

  ////////////////////////////////////////////////
  // Collect the result .
  ////////////////////////////////////////////////
  if ( num != 0 ) {

    ///////////////////////////////////////////////
    // Slaves sends the results to the master:
    printf( "result sended from %d \n" , num  ) ;
    MPI_Send( Vect , segment_size , MPI_DOUBLE , 0 , 99 , MPI_COMM_WORLD ) ;

  } else if ( num == 0 ) {

    /////////////////////////////////////////////
    // Master collect the results:
    j = 0 ;

    result_vect = (double*)calloc( sizeof(double) , segment_size*total ) ;
    for ( i = 0 ; i < segment_size - 1 ; i++  ) {
      result_vect[j] = Vect[i] ;
      j++ ;
    }

    for ( i = 1 ; i < total ; i++ ) {

      MPI_Recv( Vect , segment_size , MPI_DOUBLE , i , 99 , MPI_COMM_WORLD , &status  ) ;
      printf( "result recived from %d \n" , i  ) ;

      for ( n = 1 ; n < ( (i==total-1)?(segment_size):(segment_size-1) ) ; n++ ) {
        result_vect[j] = Vect[n] ;
        j++ ;
      }
    }

    /////////////////////////////////
    /// print the result
    FILE *fp ;
    fp = fopen( "result.tab" , "w" ) ;
    for ( i = 0 ; i < j ; i++ ) {
      fprintf( fp , "%lf \n" , result_vect[i] ) ;
    }
    fclose( fp ) ;
  }

  MPI_Finalize() ;

  return 1 ;
}

Ps. La versione single cpu e' di poche righe .......

[albatros]

lo faccio solo per il gusto di imparare e di ampliare le mie conoscenze

Secondo me è il motivo migliore...
Buon divertimento!!!!

[elmetal]