Newsgroup: it.comp.programmare
Titolo: Velocizzare un programma

Buongiorno a tutti.
 
Il mio problema è questo.
 
Ho scritto un programma in decimal basic per generare degli schemi per un 
gioco.
Gli schemi più complessi purtroppo richiedono dei tempi di elaborazione 
elevatissimi (in alcuni casi più di 24 ore).
Vorrei quindi velocizzare l'elaborazione.
Ho provato a tradurre il programma in linguaggio QBASIC e a compilare il 
sorgente, lanciando l'eseguibile dalla finestra DOS di windows: il risultato 
è stato deprimente: il programma è addirtittura più lento!!!
 
Avete dei suggerimenti per aumentare la velocità?
Il programma è già ottimizzato e non credo si possa migliorare in modo 
significativo l'algoritmo.
 
Un amico mi ha consigliato di "tradurre" il programma in C++ e di 
compilarlo.
Purtroppo le mie conoscenze informatiche risalgono al paleozoico inferiore 
ed il C è per me una nebulosa oscura...
E' una cosa complessa?
Avete altre soluzioni da suggerirmi?
 
Grazie dell'attenzione!
 
Renato de Rosa
 
 
 
 

 Avete altre soluzioni da suggerirmi?
Guarda questo:
http://it.wikipedia.org/wiki/Qb64
Supponendo che l'algoritmo sia giï¿œ ottimizzato, altre tecniche di 
ottimizzazione sono le seguenti:
- Generare codice macchina per Win64 (avendo un hardware e un sistema 
operativo a 64-bit). Il codice a 16 bit del DOS e' molto lento su 
Windows a 32 o a 64 bit. Il codice a 32 bit per Windows su Windows a 32 
bit e' un po' piu' lento del codice a 64 bit per Windows su Windows a 64 
bit.
- Sfruttare tutti i processori (e i core) disponibili. Questo richiede 
programmazione multihthreaded, che e' molto difficile e probabilmente 
non supportata dal Basic.
- Sfruttare le istruzioni vettoriali (o cosiddette "multimediali") dei 
processori Pentium 2 e successivi. Tuttavia richiede estensioni al 
linguaggio, o programmazione in assembly.
- Sfruttare il coprocessore grafico (GPU) come coprocessore vettoriale. 
Ovviamente ha senso solo se si ha un coprocessore grafico potente 
(quello per videogiochi 3D). Tuttavia richiede estensioni al linguaggio, 
o programmazione in assembly, ed e' molto complesso.
-- 
Carlo Milanesi
http://carlomilanesi.wordpress.com/

 significativo l'algoritmo.
 
Senza sapere nulla di specifico sospetto sia proprio quello il punto in 
cui hai il margine di miglioramento più elevato.

 Supponendo che l'algoritmo sia già ottimizzato, altre tecniche di 


 significativo l'algoritmo.
 
Cambiarlo con uno più efficiente invece no?
Considera anche una struttura diversa per i dati.
 
Onestamente - anche senza sapere che razza di schemi devi generare - non 
credo che il tuo algoritmo sia già ottimo e non possa essere 
migliorabile. Questo anche restando in decimal basic...
 
Forse dovresti dirci di più su cosa devi fare e come stai cercando di 
farlo... è probabile che possiamo darti delle dritte.

 equivalga ad un sentenza del tipo: "Nun ce poi fa' nulla!" :)
Potresti mostrare il programma. Mi rendo conto della volontà di 
preservare il proprio lavoro ma scommetto che qualcun altro sul pianeta 
ha già affrontato lo stesso problema (o uno simile) mettendo a 
disposizione il codice.
"generare schemi" per un gioco mi fa pensare che potresti provare un 
approccio diverso, come la programmazione a vincoli, probabilmente perdi 
molto tempo per fare una ricerca esaustiva degli schemi.

 ha scritto nel messaggio 
news:4e7adec5$0$44201$4faf...@reader1.news.tin.it...


 
ti consiglio di tradurlo in Perl sfruttando il modulo PDL
Il Perl è semplice come il Basic se vuoi ed il modulo PDL permette di 
sfruttare il calcolo vettoriale che è scritto in C ed automaticamente 
ottimizzato.
All'atto pratico scrivi solo in Perl ma il calcolo massivo viene svolto 
tramite una libreria compilata dal C e ottimizzata.
Considera che il modulo PDL è stato sviluppato da un astronomo per 
svolgere calcoli pesanti.
Per quanto riguarda il Perl invece ha una sintassi di base praticamente 
simile al Basic quindi non hai sopresone come potresti avere in C dove 
devi gestire la memoria.
Addirittura Perl capisce automaticamente dal contesto dove le usi, il tipo 
di variabile, quindi ancora più semplice del Basic.
https://secure.wikimedia.org/wikipedia/en/wiki/Perl_Data_Language/
http://pdl.perl.org/
http://www.shlomifish.org/lecture/Perl/Newbies
mute
p.s.
per curiosità
il classico "Ciao Mondo":
Perl:
print "Ciao Mondo";
VisualBasic:
Private Sub Form_Load()
Print "Ciao Mondo"
End Sub
Basic:
10 PRINT "Ciao Mondo"
C++:
#include <iostream.h>
main()
{
    cout << "Ciao Mondo" << endl;
    return 0;
}
Pascal:
program Saluta(output);
begin
  WriteLn('Ciao Mondo');
end.
Unix Shell:
echo "Ciao Mondo"
VisualBasic.NET:
Imports System.Console
Class Saluti
    Public Shared Sub Main()
        WriteLine("Ciao Mondo")
    End Sub
End Class

 disposizioni iniziali non generino lo stesso schema.
Messa così sembra non ci sia altro modo che identificare le routine più 
gravose, riscriverle in assembler e sperare che basti...
...io però proverei lo stesso a cercare delle vie alternative.
Magari c'è un modo diverso di testare l'unicità. Oppure magari (opzione 
assai sottovalutata, ma spesso risolutiva) c'è un modo diverso di 
rappresentare i dati, per cui è possibile scrivere un algoritmo più veloce.

 ha scritto nel messaggio 
news:4e7b05de$0$44202$4faf...@reader1.news.tin.it...

I dati non possono essere rappresentati in modi più efficiente, ahimè!
Faccio tre domande ingenue:
1. Evitare le subroutine (call... return) duplicando le linee di codice nel 
punti in cui veniva chiama la subroutine, può velocizzare l'esecuzione?
2. L'esecuzione può essere velocizzata lanciando il programma compilato in 
modalità DOS (non dalla finestra DOS di windows, ma avviando il computer in 
DOS - ammesso che si possa fare)?
3. Utilizzare un PC più potente di quanto può accelerare i tempi?
 
Grazie!
 
Renato
 
 
 

 posizioni iniziali.
 
Per questo suggerivo la programmazione a vincoli, ma ne ho solo letto, 
mai avvicinata.
 
Volendo restare con l'imperativo e la forza bruta puoi prendere in 
considerazione l'idea di usare una scheda video ATI e una libreria come 
openCL, python ne ha una e probabilmente anche perl che ti è stato 
suggerito in questa stessa discussione.
 
Se puoi parallelizzare, ad esempio scendendo i rami di un albero,  
questo ti permette di avere tanti core e di abbattere i tempi.
Per tanti core intendo nell'ordine delle migliaia per una spesa di un 
paio di centinaia di euro.
 
Il vantaggio in termini di tempo di esecuzione dipende dalla complessità 
dell'algoritmo ma da quanto leggo due ordini di grandezza rispetto 
all'uso della sola CPU non è un miraggio.

> 
http://it.wikipedia.org/wiki/Qb64
Ma c'hai guardato? Non mi sembra difficile da usare.


 3. Utilizzare un PC piï¿œ potente di quanto puï¿œ accelerare i tempi?
posto di avere tutta la RAM che serve, direi esattamente di quanto ï¿œ piï¿œ 
veloce il processore che usi. Cerca di parallelizzare il lavoro: con piï¿œ 
core in parallelo puoi abbassare moltissimo i tempi di calcolo senza 
problemi
Maa... usare le SSE no? Sono istruzioni vettoriali, puoi lavorare su 4 
interi o fp alla volta: non ï¿œ mica un miglioramento da buttare via.

 gravose, riscriverle in assembler e sperare che basti...
dubito...
-- 
-riko
http://www.enrico-franchi.org/
http://rik0-techtemple.blogspot.com/

 quindi il tutto si riconduca ad un problema di forza bruta elaborativa.
Io credo di no. Basta saper ottimizzare bene l'algoritmo di generazione.
Per capire, quale e' il branch-factor del gioco? Se come temo e' un b^8
(nei casi piu' gravosi) devi proprio lavorare a livello di algoritmo, se
no, buona fortuna. Non c'e' pc e non c'e' ottimizzazione che tiene. 
