Linguaggio di programmazione, quale e' il piu veloce?

[WarDuck]

Questo thread ha del paradossale, ancora non si è capito qual è il problema che l'utente dovrebbe risolvere

Prima dovresti dirci cosa stai facendo e poi forse e dico forse ci si pone il problema del linguaggio (o meglio del compilatore).

Se ci sono problemi prestazionali la prima cosa da fare è capire se si sta adottando l'algoritmo corretto, dopodiché bisognerebbe assicurarsi che tu stia dicendo al compilatore di ottimizzare il codice per la velocità, per poi passare ad un profiling del codice e capire se l'utilizzo di cache e quant'altro avviene in maniera ottimale, se si possono usare istruzioni SIMD, multithreading e via discorrendo...

Così mi pare solo una perdita di tempo.

PS: la maggior parte dei processori moderni essendo dotata di branch prediction ottimizza le istruzioni di salto quindi se il codice è abbastanza predicibile le istruzioni di salto sono quasi gratuite.

PS2: se il problema che stai affrontando ha una natura vettoriale si potrebbe pensare di usare la GPU per eseguire questi calcoli.

[soniaa]

Analizzando l'uso dei GOTO;

trovandomi nella situazione:
IF a=10 then
...bla bla bla per decine di righe...
END IF
...continuo programma...

cosi' perdo velocita', e' piu conveniente fare l'operazione contraria perche' in caso A<>10 comunque il processore legge tutto il codice per trovare "END IF" per trovare la prossima istruzione da esegiure!
IF a <> 10 then GOTO nextlabel
bla bla bla per decine di righe
END IF
nextlabel:
...continuo programma....

[soniaa]

E nel caso di ON a GOTO

ON a GOTO 1001,1003,1004,1005,500,860,etc...
anche cosi' perdo velocita' (senza contare che e' difficilmente utilizzare una logica di questo tipo perche a puo essere a volte un numero grande!!)

risulta piu veloce fare (assurdo ma e' cosi'):
IF a=1 then GOTO 1001
IF a=2 then GOTO 1003
IF a=3 then GOTO 1004
etc...

per non parlare dei "SELECT CASE" che per elaborare cio' il processore ci mette una vita!
SELECT CASE a
case 1 GOTO 1001
case 2 GOTO 1003
case 3 GOTO 1004

Una volta con i vecchiii linguaggi si poteva usare
GOTO 1000+a oppure in caso di label "GOTO a$" o GOTO VAL(a$)

[lorenzo001]

In effetti così si perde tempo a seguire il discorso ...

Per ora non ha importanza il GOTO ma capire qual è il problema.

Cosa vuoi fare con il tuo programma che pensi di risolvere in quel modo?

[soniaa]

Si, le vestre richieste di sapere a cosa sto lavorando sono lecite,
tuttavia vi informo che e' solo un hobby e null'altro.
Trovo le risposte che mi avete dato sino ad ora mooolto soddisfacenti
percui di fronte a tanta buona volonta' da parte vostra non trovo corretto rifiutarmi (perche soprattutto mi vergogno parecchio) di svelare...
Ripeto: e' solo un Hobby... e mi vergogno di fronte a voi 'espertisssssimi programmatori'...ma forse anche voi avrete imparato un po alla volta iniziando proprio da cavolate come queste? sbaglio???

Mi e' capitata sotto mano il PEG Solitaire (tavoliere inglese)
dopo ore/giorni) di gioco non sono mai riuscita a vincere,
poi ho tirato fuori il mio vecchio ZX spextrum e ho realizzato un software per trovare la soluzione, poi accortami che ci sarebbero voluti anni, ho usato un emulatore ZX sul pc e li' la volocita' e' aumentata parecchio spingendo il clock al massimo e anche il moltiplicatore, ma non era sufficiente e quindi ho usato un convertitore BASIC to ASSEMBLER, ma la velocita' non era ancora abbastanza,
quindi ho dovuto aggiornarmi e imparare il Qbasic, e' stata una impresa per me!, ma dovevo aggionarmi (dal giurassico al medievale )
La soluzione e' presto arrivata, ma ora c'e un pensiero che mi stordisce la testa giorno e notte:
voglio trovare TUTTE le soluzioni possibili!
quindi mi serve mooolta piu velocita'
mi sono accorta che il qbasic e' si piu veloce ma ha delle notevoli limitazioni
(non ha i GOTO/GOSUB 1000+a)
e l'uso di variabili del tipo a(1) a(2) a(3) portano via mooolto tempo di elaborazione e cosi mi e' toccato scrivere tutte le 33 mosse moltiplicato per 32 pedine (ho usato WORD trova e sostituisci ovviamente)
Poi mi sono accorta che la memoria in Qbasic e' poca e quindi ho provato il QuickBasic, ma ancora non basta la memoria
Poi ho trovato il QB64
qui la memoria e' abbastanza, ma comunque non tutta quella che mi servirebbe...ma diciamo che riesco ad adattarmi...
Comunque servono 100 anni per trovare tutte le soluzioni (miliardi di combinazioni diverse!!)
Ora l'idea di interpretare il mio programma in una logica binaria
il numero da elaborare e' di 33 bit (33 sono i fori della scacchiera) e cosi' non devo usare variabili del tipo a(1) a(2) ma solo variabili a1,a2,a3,a4 etc
quindi:
esempio:a=&B100000000011111000001111100000111
per trovare velocemente le pedine da muovere e non passare tutti i bit cercando il prossimo a valore 1 userei il logaritmo che mi avete consigliato:

la prima pedina esistente la posso trovare cosi':
if a>&B 100000000000000000000000000000000 (significa che nella scacchiera il foro 1 e' occupato)

la prossima e';
33(decimale) - (INT(ln &B10000000000000000000000000000000))/(ln 2)+1

e cosi' via
ancora non ho testato questa logica, e' per questo che ho chiesto se vi era una formula, e mi e' stata data, ora la provero'....
ho anche chiesto appunto visto che devo riscrivere l'intero programma se mi conveniva scriverlo in un linguaggio piu veloce perche ho il presentimanto che anche cosi ci vorranno anni di calcoli....
Arrampicandomi sugli specchi potre considerare anche che ho diversi PC a casa e sono multiprocessore X4 e X8,
quindi potrei 'scorporare' il programma e farlo elaborare a pezzi su diversi pc,,
se ho ho 1 pc a 8 processori e 4 pc a 4 processori vuol dire che riesco a processare (1 x 8) + (4 x 4) =24 ad una velocita x 24 volte
Ciao, ora ridete pure

[NorysLintas]

Che io sappia e come ti è stato già detto, se questo hobby e la tua pazienza te lo permettono, impara l'assembly e riformula l'algoritmo.
E' il linguaggio di programmazione di livello più basso e di conseguenza è anche il più veloce, se poi sbaglio correggetemi.

[lorenzo001]

Se lo riscrive in C usando un buon compilatore che usa decenti criteri di ottimizzazione, ottiene sicuramente un risultato apprezzabile.

[ingframin]

Non è necessario imparare assembly, è solo necessario aggiornarsi un poco
e riscrivere il programma in un linguaggio moderno facendo uso di cose moderne.
Puoi perfino usare Java secondo me...
http://it.wikipedia.org/wiki/Peg_Solitaire

Il problema è NP complesso effettivamente, però secondo me ce la fai anche senza spendere anni

[epimerasi]

Originariamente inviato da soniaa

Si, le vestre richieste di sapere a cosa sto lavorando sono lecite,
tuttavia vi informo che e' solo un hobby e null'altro.
Trovo le risposte che mi avete dato sino ad ora mooolto soddisfacenti
percui di fronte a tanta buona volonta' da parte vostra non trovo corretto rifiutarmi (perche soprattutto mi vergogno parecchio) di svelare...
Ripeto: e' solo un Hobby... e mi vergogno di fronte a voi 'espertisssssimi programmatori'...ma forse anche voi avrete imparato un po alla volta iniziando proprio da cavolate come queste? sbaglio???

Mi e' capitata sotto mano il PEG Solitaire (tavoliere inglese)
dopo ore/giorni) di gioco non sono mai riuscita a vincere,
poi ho tirato fuori il mio vecchio ZX spextrum e ho realizzato un software per trovare la soluzione, poi accortami che ci sarebbero voluti anni, ho usato un emulatore ZX sul pc e li' la volocita' e' aumentata parecchio spingendo il clock al massimo e anche il moltiplicatore, ma non era sufficiente e quindi ho usato un convertitore BASIC to ASSEMBLER, ma la velocita' non era ancora abbastanza,
quindi ho dovuto aggiornarmi e imparare il Qbasic, e' stata una impresa per me!, ma dovevo aggionarmi (dal giurassico al medievale )
La soluzione e' presto arrivata, ma ora c'e un pensiero che mi stordisce la testa giorno e notte:
voglio trovare TUTTE le soluzioni possibili!
quindi mi serve mooolta piu velocita'
mi sono accorta che il qbasic e' si piu veloce ma ha delle notevoli limitazioni
(non ha i GOTO/GOSUB 1000+a)
e l'uso di variabili del tipo a(1) a(2) a(3) portano via mooolto tempo di elaborazione e cosi mi e' toccato scrivere tutte le 33 mosse moltiplicato per 32 pedine (ho usato WORD trova e sostituisci ovviamente)
Poi mi sono accorta che la memoria in Qbasic e' poca e quindi ho provato il QuickBasic, ma ancora non basta la memoria
Poi ho trovato il QB64
qui la memoria e' abbastanza, ma comunque non tutta quella che mi servirebbe...ma diciamo che riesco ad adattarmi...
Comunque servono 100 anni per trovare tutte le soluzioni (miliardi di combinazioni diverse!!)
Ora l'idea di interpretare il mio programma in una logica binaria
il numero da elaborare e' di 33 bit (33 sono i fori della scacchiera) e cosi' non devo usare variabili del tipo a(1) a(2) ma solo variabili a1,a2,a3,a4 etc
quindi:
esempio:a=&B100000000011111000001111100000111
per trovare velocemente le pedine da muovere e non passare tutti i bit cercando il prossimo a valore 1 userei il logaritmo che mi avete consigliato:

la prima pedina esistente la posso trovare cosi':
if a>&B 100000000000000000000000000000000 (significa che nella scacchiera il foro 1 e' occupato)

la prossima e';
33(decimale) - (INT(ln &B10000000000000000000000000000000))/(ln 2)+1

e cosi' via
ancora non ho testato questa logica, e' per questo che ho chiesto se vi era una formula, e mi e' stata data, ora la provero'....
ho anche chiesto appunto visto che devo riscrivere l'intero programma se mi conveniva scriverlo in un linguaggio piu veloce perche ho il presentimanto che anche cosi ci vorranno anni di calcoli....
Arrampicandomi sugli specchi potre considerare anche che ho diversi PC a casa e sono multiprocessore X4 e X8,
quindi potrei 'scorporare' il programma e farlo elaborare a pezzi su diversi pc,,
se ho ho 1 pc a 8 processori e 4 pc a 4 processori vuol dire che riesco a processare (1 x 8) + (4 x 4) =24 ad una velocita x 24 volte
Ciao, ora ridete pure

Stai cercando di risolvere un problema NP-completo.
A seconda della dimensione dell'istanza del problema (e si fa molto presto ad arrivarci con questo tipo di problemi), potrebbe non bastarti neanche il computer della NSA.


http://en.wikipedia.org/wiki/Peg_sol..._peg_solitaire

http://xorshammer.com/2008/11/03/how...ames-are-hard/

http://en.wikipedia.org/wiki/NP-completeness

[gugoXX]

Che sfiga eh... 33 bit

[gugoXX]

Originariamente inviato da soniaa

TEST 3 (puro calcolo) QB64 54sec Fortran 110sec

QB64 code:
DIM a AS LONG
FOR a = 1 TO 1000000000
b = a / 1003 + a / 1005
c = a / 1008 + a / 1002
d = a / 1001 + a / 1006
NEXT a

Fortran code:
program first
integer a,b,c,d
b=12
c=13
d=14
do a=1,1000000000
b = a / 1003 + a / 1005
c = a / 1008 + a / 1002
d = a / 1001 + a / 1006
end do
end program first

C# 21 sec.
(Ma non sono paragonabili, ovviamente la mia macchina e' diversa dalla tua)

static void Main(string[] args)
        {
            int b,c,d;
            b=12;
            c=13;
            d=14;
            Stopwatch sw = Stopwatch.StartNew();
            Parallel.For(1, 1000000000, a =>
            {
                var b1 = a / 1003 + a / 1005;
                var c1 = a / 1008 + a / 1002;
                var d1 = a / 1001 + a / 1006;
            });
            sw.Stop();
            Console.WriteLine("Elapsed {0}sec", sw.ElapsedMilliseconds / 1000);
            Console.ReadKey();
        }

Immagino in C venga fuori ancora meglio

[ingframin]

Originariamente inviato da gugoXX

C# 21 sec.
(Ma non sono paragonabili, ovviamente la mia macchina e' diversa dalla tua)

static void Main(string[] args)
        {
            int b,c,d;
            b=12;
            c=13;
            d=14;
            Stopwatch sw = Stopwatch.StartNew();
            Parallel.For(1, 1000000000, a =>
            {
                var b1 = a / 1003 + a / 1005;
                var c1 = a / 1008 + a / 1002;
                var d1 = a / 1001 + a / 1006;
            });
            sw.Stop();
            Console.WriteLine("Elapsed {0}sec", sw.ElapsedMilliseconds / 1000);
            Console.ReadKey();
        }

Immagino in C venga fuori ancora meglio

package spdtst;

public class SpeedTest {

	public static void main(String[] args) {
		long b,c,d;
		b=12;
		c=13;
		d=14;
		long now = System.nanoTime();
		for(int a=0;a<1000000000;a++){
			long b1 = a / 1003 + a / 1005;
			long c1 = a / 1008 + a / 1002;
			long d1 = a / 1001 + a / 1006;
		}
		long stop = System.nanoTime();
		System.out.println("Elapsed time=");
		System.out.println((stop-now)/1000);
	}

}

Java da dentro Eclipse impiega tra i 5 e gli 8 ms
Secondo me c'e' qualcosa che rallenta il tuo codice c# oppure ho sbagliato io a tradurre il sorgente.

[ingframin]

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

int main()
{
    long b,c,d;
    int a;
    long b1;
    long c1;
    long d1;
    clock_t start, stop;
    b=12;
	c=13;
	d=14;
	start = clock();
	for(a=0;a<1000000000;a++){
		b1 = a / 1003 + a / 1005;
		c1 = a / 1008 + a / 1002;
		d1 = a / 1001 + a / 1006;
	}
    stop = clock();
	printf("Elapsed time=\t%.9f\t%.9f",stop,start);

    return 0;
}

Questo e' in C. Pero' c'e' qualcosa che non mi torna nella misura dei tempi...

[Storti]

Originariamente inviato da ingframin

printf("Elapsed time=\t%.9f\t%.9f",stop,start);

Questo e' in C. Pero' c'e' qualcosa che non mi torna nella misura dei tempi...

Prova così:

printf("Elapsed time: %f\n", (stop - start) / CLK_TCK);

La misurazione che hai fatto col programma Java è evidentemente sbagliata.

[vendettaaaaa]

@infrag e gugo: grazie al cazzo, non usate le variabili quindi in release il compilatore salta tutto il ciclo a piè pari!!
Nel ciclo cmq assegnate a b, c e d, non create delle var (o dei long) aggiuntive visto che il codice originale assegna a b, c, d.
Fate stampare b alla fine, insieme al tempo, e vedrete che in release ci vorranno un paio di secondi almeno (2 sec sul mio i5 vecchio di 2 anni).

[vendettaaaaa]

Su i7 3770K @default:

con MinGW 4.8.1 in DEBUG (perchè in release MinGW salta il ciclo e calcola direttamente b con a = 1000000000, mettendoci 0 secondi):
https://public.bn1.livefilestore.com...CPP.JPG?psid=1

con gfortran 4.8.1 in DEBUG:
https://public.bn1.livefilestore.com...F77.JPG?psid=1

Con gfortran in release ci mette 1.9 secondi circa, quindi siamo lì, il limite inferiore è sui 2 secondi con questa potenza di calcolo.

[ingframin]

Originariamente inviato da Storti

Prova così:

printf("Elapsed time: %f\n", (stop - start) / CLK_TCK);

La misurazione che hai fatto col programma Java è evidentemente sbagliata.

Mi spieghi come correggerla quella in Java?
Credevo che usando System.nanoTime() venisse precisa la misura.
Quello che non mi torna e' la precisione.
Da documentazione sono nanosecondi, quindi diviso 1000 sono microsecondi.
~5000 microsecondi sono millisecondi.
Dove sbaglio?

Execution time datomi da Codeblocks per la versione in C=0.010s... Sono 10 millisecondi.
Anche con la printf che mi suggerisci tu mi stampa sempre elapsed time 0.000000

EDIT:
Stampando le variabili il tempo della versione Java sale a circa 9s
Il tempo della versione in C rimane sui 12ms

[vendettaaaaa]

Originariamente inviato da ingframin

Mi spieghi come correggerla quella in Java?
Credevo che usando System.nanoTime() venisse precisa la misura.
Quello che non mi torna e' la precisione.
Da documentazione sono nanosecondi, quindi diviso 1000 sono microsecondi.
~5000 microsecondi sono millisecondi.
Dove sbaglio?

Non so se hai letto, ma al 99% delle probabilità il ciclo che hai scritto viene (intelligentemente) saltato in toto dal compilatore, per quello ci mette solo 8 millisecondi.

[airon]

Per curiosità ho provato sul mio mac i7-3770, in terminale.
Quindi ho usato time da li.

compilando con gcc senza nessuna ottimizzazione:
B= 1992032
real 0m9.285s
user 0m9.278s
sys 0m0.006s

gcc -O2:

B= 1992032
real 0m0.003s
user 0m0.001s
sys 0m0.001s

[vendettaaaaa]

Originariamente inviato da airon

Per curiosità ho provato sul mio mac i7-3770, in terminale.
Quindi ho usato time da li.

compilando con gcc senza nessuna ottimizzazione:
B= 1992032
real 0m9.285s
user 0m9.278s
sys 0m0.006s

gcc -O2:

B= 1992032
real 0m0.003s
user 0m0.001s
sys 0m0.001s

gcc con le ottimizzazioni calcola il ciclo con a = 999999999 (cioè l'ultimo valore), per quello ho fatto le prove in debug.