Newsgroup: it.comp.lang.delphi
Titolo: Velocizzare una funzione ci confronto

Ciao,
sto lavorando ad un'applicazione di analisi statistica che funziona 
correttamente ma date le operazioni che deve svolgere mi risulta un po' 
lentina...
Per farvi un'esempio per processare circa 10 milioni di cicli, e ogni ciclo 
potrebbe doverlo iterare da 0 a 150 volte (secondo una certa operazione di 
confronto che breakka se restituisce true), gli occorrono circa dodici 
minuti...il problema � che l'utente potrebbe chiedere 100...500 milioni di 
cicli con fino a mille e passa iterazioni per ciclo, che richiedono anche 
10/11 ore.
In sostanza l'applicazione crea dinamicamente, in maniera ciclica (da una 
decina fino a 500 milioni secondo le impostazioni dell'utente), un array di 
x byte sempre diverso e lo confronta con un array of array of integer 
memorizzato in partenza...
 
for i := low(arrayDato) to high(arrayDato) do
begin
  if Terminated then exit;
  verify := 0;
  for ciclo := 0 to 5 do
    begin
      { h[] � l'array creato dinamicamente }
      if arrayDato[i, ciclo] in [h[0],h[1],h[2],h[3],h[4],h[5]] then 
inc(cx);
   end;
   if cx >= limit then
     begin
      { faccio delle cose secondo il valore di cx }
      { chiamo dei Synchronize }
      break;
    end
      else { altre cose }
end;
 
Ho anche provato a lavorare direttamente con i puntatori per effettuare il 
confronto ma i tempi sono gli stessi, anzi un minuto in pi� rispetto ai 
dodici sopraddetti.
 
La domanda �, tenendo conto che il loro tempo lo richiederanno anche le 
operazioni svolte all'interno dei blocchi oltre alle chiamate a Synchronize 
voi avete suggerimenti alternativi per l'istruzione di confronto?
Pensate che riscrivere *solo* l'operazione di confronto in asm potrebbe 
portare differenze significative?
In caso affermativo qualche linketto per schiarirmi le idee giacch� di asm 
non ne so prp un bel niente (ma penso che con un po' di buona volont� e 
tempo non dovrebbe essere impossibile).
 
Grazie
 
Valter
 
 

Io comincerei da questo:
 
var
  c: char;
....
 
 for ciclo := 0 to 5 do
    begin
       c :=  arrayDato[i, ciclo]
       if pos(c, h) > 0 then
       begin   
        inc(cx);
       end;
   end; 
.....


  guarda se la sostituisci con (piu') elementi statici
if arrayDato[i, ciclo] in [h[0],h[1],h[2],h[3],h[4],h[5]]
 
  Il Synchronize attende l'idle dei messaggi e questo puo' rallentare, 
prova con i semafori e vedi se guadagni qualcosa
giorgio

 end;
 
Dentro il for cerca di eliminare il piu possibile le chiamate a funzioni 
esterne.
Prova a sostituire
 
L := low(arrayDato); H := high(arrayDato);
for i := L to H do
 
Terminated è una funzione? Cosa fa? Chiama altre funzioni?
e poi bisogna vedere cosa c'è nell'ultimo blocco dove dici che fai cose =)
 
 
 

Grazie a tutti per i suggerimenti.
Per arrivare al dunque ho commentato banalmente tutto il contenuto del ciclo 
principale che crea l'array di base e una dopo l'altra decommentate le 
procedure e funzioni al suo interno.
Risultato: indiziato e colpevole senza scampo Synchronize.
Devo scendere a compromessi, refreshare contatori e progress bar a step pi� 
ampi e/o provare con i semafori.
Comunque gi� cos� da 12min sono sceso a 3, potrebbe andare...
 
Ciao
 
Valter