Tecnicamente's Weblog

Just another WordPress.com weblog

Archivi Mensili: marzo 2011

Arduino, si comincia

Questa sera mi sono finalmente convinto a comprare uno starter Kit per Arduino UNO.

Prossimamente su questi schermi ūüôā

Fortran parte 3: Fortran Vs. C/C++ o compilatore Vs. compilatore?

Basta fare una ricerca dove si vogliono recuperare informazioni circa le performances offerte dal Fortran95 contro C/C++ e si trovano centianai di benchmark a favore dell’uno e dell’altro linguaggio.

Se poi si va su gruppi di discussione si assiste a vere e proprie guerre di religione per partito preso e che quasi sempre si concludono con insulti.

Non √® mia intenzione schierarmi dall’una o dall’altra parte, credo semplicemente che i software, come qualsiasi altra cosa, sono dei prodotti che devono essere ingegnerizzati.

Quindi quando c’√® da metter gi√Ļ due righe di codice si pu√≤ partire alla “garibaldina”, ma quando le cose sono serie ed impegnative occorre spendere del tempo per svolgere delle analisi e successivamente impostare l’architettura del software e la scelta degli strumenti da usare.

Tra gli strumenti c’√® sicuramente il linguaggio di programmazione, difficilmente un solo linguaggio √® adatto a coprire tutti gli scopi.

Attenzione, con un linguaggio come ad esempio il C o il C++ si pu√≤ fare praticamente tutto, non a caso sono “general purpose“, e devo essere sincero, sono un grande ammiratore di questi linguaggi e delle loro potenzialit√†.

Ma in un ambiente di produzione il fattore tempo è fondamentale, il ricorso a strumenti che facilitano certe parti del progetto è, a mio parere, obbligatorio.

Il Fortran non si pone come un linguaggio per risolvere qualsiasi problema, il Fortran si pone come un linguaggio per la soluzione di problemi numerici.

In tale ottica offre una serie di strumenti che altri linguaggi non hanno, per capirci dovendo spiegare quale √® il linguaggio pi√Ļ somigliante al fortran, io dire Matlab.

La sostanziale differenza è che Fortran necessita di compilatori, Matlab mi pare sia in pseudocodice.

Ma torniamo alla questione Fortran Vs. C/C++, voglio solo fare degli esempi per dare una idea di quello che mi piace del Fortran ma anche del C/C++.

Si prenda in considerazione l’esempio seguente, una matrice B contiene dei valori numerici, ed una seconda matrice A √® nulla.

Si vuole che A assuma gli stessi elementi di B quando questi sono pari.

Il problema proposto è solo uno spunto per mostrare le capacità del linguaggio.

In C si può scrivere il seguente programma:

#define X 15000
#define Y 15000
#define ESECUZIONE 5

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

int main(void)
{
  int i,j,k;
  int **a;
  int **b;

  for(k=0;k<ESECUZIONE;k++)
  {
    a = malloc(sizeof(int)*X);
    b = malloc(sizeof(int)*X);

    for(i=0;i<Y;i++)
    {
      a[i] = malloc(sizeof(int)*Y);
      b[i] = malloc(sizeof(int)*Y);

      for(j=0;j<Y;j++)
      {
        b[i][j] = j+1;
      }
    }

    for(i=0;i<X;i++)
    {
      for(j=0;j<Y;j++)
      {
        if((b[i][j]%2)==0)
        {
          a[i][j] = b[i][j];
        }
      }
    }
    printf("%d\n",a[10-1][10-1]);

    for(i=0;i<X;i++)
    {
      free(a[i]);
      free(b[i]);
    }
    free(a);
    free(b);
    return 0;
}

return 0;
}

Come si potrebbe scrivere lo stesso programma in Fortran95?
Ecco la risposta:

program esempio
implicit none

integer, parameter :: X = 15000
integer, parameter :: Y = 15000
integer, parameter :: ESECUZIONE = 5

integer :: i,j,k

integer, allocatable :: A(:,:), B(:,:)

do k=1,ESECUZIONE
 allocate(A(X,Y))
 allocate(B(X,Y))

 A = 0

 do j=1,Y
     B(:,j) = (/(i,i=1,X)/)
 enddo

 where(mod(B,2)==0) A=B

 write(*,*) B(10,10)

 deallocate (A)
 deallocate (B)

enddo
end program esempio

o pi√Ļ sinteticamente:

program esempio_2
implicit none

integer, parameter :: X = 15000
integer, parameter :: Y = 15000
integer, parameter :: ESECUZIONE = 5

integer :: i,j,k

integer, allocatable :: A(:,:), B(:,:)

do k=1,ESECUZIONE
	allocate(A(X,Y))
	allocate(B(X,Y))

	A = 0

	forall(j=1:Y)
		B(:,j)=j
	end forall

	where(mod(B,2)==0) A=B

	write(*,*) B(10,10)

        deallocate (A)
	deallocate (B)
enddo
end program esempio_2

La cosa evidente, a prescindere da fatto che abbiate capito qualcosa nel codice Fortran :), è che in Fortran le linee di codice richieste sono effettivamente poche, e vi assicuro che se si conosce il linguaggio sono anche estremamente leggibili.

Vi ho mostrato due versioni in Fortran95, la differenza tra i due sta nel fatto che nel primo codice uso un ciclo DO…ENDDO per riempire la matrice B lungo le colonne, ci√≤ √® necessario per velocizzare gli accessi in memoria visto che il Fortran organizza i dati in memoria seguendo l’ordine delle collone, a differenza del C/C++ che seguno le righe.

Nel secondo codice il ciclo DO…ENDDO precedende √® sostituito dal un ciclo FORALL…END FORALL, tale ciclo √® molto particolare, e dovrebbe dare il meglio di se su architetture multiprocessore.

Infatti FORALL implementa il calcolo parallelo nativamente e direttamente dal compilatore, cosa non da poco, purtroppo io dispongo di un sistema non proprio performante e per di pi√Ļ monoprocessore infatti eccovi la scheda del mio sistema:

Adesso passiamo alla copilazione ed al “benchmark” dei codici.

Per la precisione user√≤ una versione per usi non commerciali del compilatore Fortran di Intel e l’immancabile gcc per il codice in C.

Compilo i primi due codici ed ottengo:

Quale è la conclusione?

La velocità dipende:

– dal tempo impiegato a scrivere tutte le righe di codice

– da come il programmatore implementa il codice

– dal tempo impiegato a debuggare

– dalle ottimizzazioni realizzate dal compilatore

Circa l’ultimo punto ho una domanda, come mai gfortran che poi √® gcc impiega pi√Ļ tempo rispetto alla versione in C, mentre il compilatoreo ifort impiega praticamente lo stesso tempo di gcc?

Ovviamente questo test non è un test valido per qualificare le prestazioni dei compilatori.

Se qualcuno prova ed eseguire i test su una macchina dual core mi farebbe piacere avere i risultati.

In tal caso il codice fortran da usare √® il secondo dove √® presente l’istruzione FORALL.

Appena recupero i sorgenti della mia tesi, vedo di eseguire un test sui diversi compilatori, a suo tempo impiegava 60 ore, compilatore Compaq Visual Fortran e un bel PC da 3200 Mhz.

Fortran parte 2: Passare i parametri dalla riga di comando

Mi è sempre piacuta la possibiltà di passare dei parametri ad un programma nel momento in cui lo si lancia dalla riga di comando.

Ciò è estremamente semplice in C/C++, basta infatti:

#include<stdio.h>
int main(int argc, char* argv[])
{
    int i;
    printf("Passati %d parametri\n",argc);
    printf("I parametri sono:\n");
    for(i=1;i<argc;i++) { printf("%s\t",argv[i]);}
    printf("\n");  
    return 0;
}

Sono rimasto sorpreso e stupito che lo si possa fare con il fortran9x, occore richiamare due funzioni native ed ecco:

program parametri
 implicit none
 integer :: argc, i
 character(len=256) :: argv

 argc = command_argument_count()
 argnum = command_argument_count()
 write(*,*)  "Numero argomenti: ",argc 
 do i = 1, argc
  call get_command_argument(i,argv)
  write(*,*) argv
 end do
end program parametri


Un modo diverso per ottenere lo stesso risultato  è il seguente:

program parametri
    implicit none
    
    integer :: i, n_of_arg
    character(10) :: argv
    
    
    write(*,*) "Numero argomenti: ", iargc()

    do i=1,iargc()
        call getarg(i,argv)
        write(*,*) argv
    enddo
end program parametri

Fortran Parte I: Gli array in Fortran95

Molti ridono quando sentono parlare del Fortran, ma di fatto chi programma in tale linguaggio non è mai un informatico di professione.

In genere chi usa tale linguaggio è una persona che necessita di scrivere del software che si deve interfacciare direttamente a persone o sistemi, ma per la precisione, scrive  software per il calcolo numerio.

Tutti i linguaggi sono pensati per eseguire calcoli, ma nessuno permette di ottenere le prestazioni e la semplicità di base che si può ottenere con il Fortran95.

In questa breve nota mostrer√≤ l’aspetto che pi√Ļ apprezzo di questo linguaggio, e che alla fine √® quello che mi impedisce anche di passare al C o similari, parliamo di ARRAY!

ARRAY in FORTRAN

Un Array è un insieme di dati omogenei, e non differesiche in nulla da quelli che sono gli array in altri linguaggi.

Possiamo quindi avere:

  • Array di numeri interi
  • Array di numeri reali
  • Array di numeri complessi
  • Array di caratteri
  • Array di tipi personali, cio√® di tipi creati per uno scopo preciso

Ancora una volta gli array possono essere statici o dinamici, e vedremo pi√Ļ avanti cosa vuol dire.

Per un ingegnere, un fisico, un matematico, un chimico, una persona che vuol fare dei calcoli, l’array non √® altro che una MATRICE.

Possiamo avere array monodimensionali, quindi avremo un VETTORE, o array multimensionali quindi MATRICI.

In molte materie scientifiche si realizza un modello matematico basato su matrici ed il calcolo matriciale per semplificare il problema.

Gli esempi sono innumerevoli:

  • L’analisi del moto dei corpi celesti
  • La scienza delle costruzioni
  • L’analisi agli elementi finiti
  • La fluido dinamica numerica
  • L’aerodinamica applicata
  • ecc.

Per cui possedere un linguaggio che gestisca in modo diretto le matrici non è cosa da poco.

Passiamo agli esempi ūüôā

Dichiarazione degli ARRAY

integer :: matrice(10,10)
integer, dimension(10,10) :: matrice

con le due dichiarazioni precedenti si crea una matrice di interi di rango 10×10

analogamente si può creare un vettore di numeri reali o complessi:

double precision :: vettore(10)
double precision, dimension(10) :: vettore

Le dichiarazioni precedenti sono usate quando si conosce a priori la dimensione dell’array da usare, in molti casi si pu√≤ avere a che fare con array dalle dimensioni sconosciute, in tal caso occore usare gli array dinamici ed allocare di volta in volta lo spazio i memori necessario.

La dichiarazione √® simile alla precedende, ma al posto della dimensione si inserisce il simbolo “:”.

integer, allocatable :: matrice(:,:)
integer, allocatable, dimension(:) :: vettore
ALLOCATE(matrice(10,10))
ALLOCATE(vettore(10))

Per liberare la memori quando le matrici non sono pi√Ļ necessarie basta:

DEALLOCATE(matrice)
DEALLOCATE(vettore)

ASSEGNAZIONI DI VALORI AGLI ARRAY

Gli array possono essere usati come semplici variabi sia con la metodologia di accesso in lettura e scrittura basata su indici, quindi:

WRITE(*,*) A(i,j) -> stampa l'elemento di coordinate (i,j)
A(i,j) = 5 -> assegnail valore 5 all'elemento di coordinate (i,j)

Ma fin qui tutto √® in linea con le possibilit√† offerte da C/C++, vediamo quindi le peculiarit√† circa l’uso degli array.

INTEGER :: A(10,20;30)  ! creo un array di interi 10x20x30
A = 1 ! tutti gli elementi dell'array sono pari ad 1
A(1,:,:) = 2 ! tutti gli elementi che hanno il primo indicie pari a 1 assumono valore 2, quindi A(1,1,1) = 2, A(1,1,3) = 2, ..., A(1,20,30) = 2
A(1,1,:) = 3 ! tutti gli elementi di coordinate inizilia (1,1) hanno valore = 3, quindi A(1,1,1)=3, A(1,1,2)=3, ...; A(1,1,30) = 3
C = A+B !somma indice ad indice gli elementi di un array ovviamente si può avere anche la sottrazione
 
C=A*B ! moltiplica indice ad indice 

Tali modi di accesso possono essere usati per ridurre le righe di codice, semplificare la lettura e permette al compilatore di implementare l’ottimizzazione migliore di accesso, specialmente quando si ha a che fare con migliaia o milioni di elementi.

FUNZIONI NATIVE PER GLI ARRAY

Il linguaggio offre delle funzioni native per particolari operazioni su array quali:

DOT_PRODUCT(A, B) ! prodotto scalare di A e della B
MAXVAL(A)  !  restituisce il valore maggiore dell'array A
MINVAL(A)  !restituisce  il valore minore di A
MAXLOC(A)  !  restituisce le coordinate le valore maggiore di A
MINLOC(A)  ! restituisce le coordinate del valore minore di A
PRODUCT(A)  ! prodotto degli elementi di A
SUM(A) ! somma gli elementi di A
TRANSPOSE(A) ! crea la matrice trasposta

e molte altre ancora per fare lo scorrimento degli elementi, la scelta di elementi da leggere o scrive con l’applicazioni di filtri (chiamati maschera) ecc.

Il mio intento non è quello di scrivere una guida, se il linguaggio vi interessa potete chiedere qui o consultare i diversi manuali che si trovano in rete.

vi lascio con un piccolo esempio:


Qui il risultato:

Ci sarebbe ancora molto da scrivere, ma sarà per la prossima volta.

Infatti non abbiamo parlato di compilatori, lo faremo prossimamente, per ora vi lascio qualche link per curiosare e provare se queste poche note vi hanno incuriosito.

http://hpff.rice.edu/index.htm

http://www.dmi.units.it/~chiarutt/didattica/parallela/fortran/index.html

http://www.nsc.liu.se/~boein/f77to90/f77to90.html#index