Newsgroup: it.comp.lang.delphi
Titolo: [Un pò OT] Prestazioni

Mi servirebbe un vostro punto di vista (a spanne)...
Ho un codice in D7 che deve operare un'infinitā di calcoli e relative 
verifiche (attualmente 3/4 gg ininterrotti ma potrebbe in seguito 
richiederne molti di pių)
A prescindere dal mio sorgente, che magari potrebbe essere ottimizzato e 
restituire prestazioni pių elevate, in termini percentuali quanto si 
potrebbe guadagnare con un porting in C++ od in Assembler (ripeto, a grandi 
linee in quanto potrebbero essere molti i fattori in gioco)?
Ciao e grazie
V.

linee in quanto potrebbero essere molti i fattori in gioco)?
Se si tratta di calcolo numerico e se usi la unit Math, sotituendo le
sue funzioni con altre scritte in assembly il tuo codice sarà circa
100 volte più veloce.
jk


Bella domanda! Potrebbe essere la scintilla per scatenare un
bel flame ... o forse no, ma ho una brutta sensazione ...
;-)
Comunque, dovresti fornire qualche informazione in più:
- Di che complessità sono i calcoli che devi fare: infinite somme
oppure sono implicate funzioni più o meno complesse
(dal punto di vista implementativo, ovviamente: calcoli finanziari,
operazioni trigonometriche, calcoli matriciali, ecc...)?
- Che tipo di dati utilizzi: interi, reali, o altro?
- Quale hardware sfrutti?
Dal basso della mia limitatissima esperienza, rischio l'insulto stilando
una possibile classifica di velocità (dando per scontato che di
ciascun linguaggio si sia utilizzato il miglior compilatore, il codice
più performante per quel particolare calcolo e la "gara" si corra sulla
stessa macchina): il più lento sarà Delphi (diciamo, il meno veloce ...),
poi leggermente in vantaggio ci sarà il C++, poi il C ed infine inanzi a
tutti troveremo l'Assembler. Tutto IMO.
Ah, un'ultima cosa: sappi che qualunque calcolo tu esegua, qualunque
codice tu scriva, qualunque linguaggio tu utilizzi, qualsiasi hardware tu
possa sfruttare, il risultato finale delle tue elaborazioni sarà sempre
42.
;-)
Ciao
-- 
ACSH
[D4]
Chi fa da se', fatica il doppio

 linee in quanto potrebbero essere molti i fattori in gioco)?
potresti anche perderci, dipende da quanto ottimizzi.
ciao
p.s. Visto che e' gia' scritto, ottimizzarlo in delphi?
-- 
-------------------------------
per scrivere in privato
togliere "1975nosp"
to reply remove "1975nosp"

potrebbe guadagnare con un porting in C++ od in Assembler
In assembly moltissimo, in C++ poco o nulla di più.  E' una
valutazione a spanne, ovviamente.  D'altronde, confrontare Delphi al
C++, senza considerare alcuna implementazione specifica di
quest'ultimo, è inappropriato perché si confronta un ambiente di
sviluppo con un linguaggio.  Dovresti, invece, chiedere quali
sarebbero le performance se il codice venisse compilato con C++
Builder o Visual C++.


Oltre quello già detto
vorrei consigliarti l'utilizzo di un memory manager gratuito, come quello
utilizzato nelle ultime versioni di Delphi: FastMM
Puoi trovare maggiori info su:
 
http://fastmm.sourceforge.net
L'utilizzo è automatico e "banale":
"Place this unit as the very first unit under the "uses" section in your   project's .dpr file"
Ho trovato un notevole miglioramento soprattutto nella gestione di routine di grafica
dove la matematica è pesante.
Ciao
GP

 C++ od in Assembler
[cut]
Mi rendo conto di essere stato troppo vago. In realtà le operazioni eseguite 
sono molto banali ma possono arrivare ad un numero che non so neanche 
pronunciare.
Mi spiego.
Creo un array dinamico:
var myArray : array of array of byte;
setlength(myArray, 120, 7); // i valori possono cambiare
con semplici cicli for annidati riempio l'array // questa operazione è 
svolta una tantum all'avvio del prg quindi non influisce sui tempi
Lo stress comincia adesso: lo scopo è quello di prendere a gruppi (in numero 
da definire) alcuni elementi dell'array (che a loro volta posiziono in un 
array), verificare delle condizioni confrontando tutto l'array con il gruppo 
estrapolato, prendere un successivo gruppo con un solo elemento diverso dal 
precedente e procedere nello stesso modo fino ad esaurire tutte le possibili 
combinazioni degli elementi componenti l'array.
Il problema sta nella q.tà di confronti.
Nell'esempio citato se i miei gruppi fossero da 7 elementi il numero delle 
possibili combinazioni è dato da
120 su 7 => 120! / 7!(120-7)! => 59.487.568.920 possibili combinazioni
ma se ad esempio l'array di partenza fosse myArray(330, 7) con gruppi 
composti da 9 elementi avrei
114.570.488.970.387.450 combinazioni
ognuna di queste combinazioni come detto deve essere confrontata con tutti 
gli elementi dell'array...in realtà se si verifica la condizione posso 
uscire dal ciclo con un break il che mi evita tutti i successivi inutili 
controlli ma è molto molto marginale.
Sulla mia macchina riesco a calcolare circa 2 miliardi e mezzo di 
combinazioni l'ora (se la memoria non mi inganna).
Lo scopo di tutto questo? Cercare di guadagnarmi un posto nel guinness dei 
primati di calcolo combinatorio :-)
Quindi mi chiedevo se valeva davvero la pena di fare un porting in C (che 
mastico) o addirittura sprofondare nell'assembler (del quale non so una 
cippa ma effettivamente il mio codice da Unit Main a End. consta di poco 
meno di 300 righe riducibili ulteriormente - 10 volte di più in assembler?). 
O forse utilizzare Delphi e richiamare solo le routine di controllo in 
assembler? Mah!
Ciao
Valter

 Quindi mi chiedevo se valeva davvero la pena di fare un porting in C[...]
Anche se non condivido i tuoi scopi, secondo me devi parallelizzare il
calcolo.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 calcolo.
Vabbè, la condivisione dello scopo è secondaria ;-) , certo non ha scopi di 
lucro ma anche le soddisfazioni personali tante volte...
Se intuisco cosa intendi per parallelizzare il calcolo ci ho pensato 
anch'io, ma è meno banale di quanto possa sembrare...
Grazie
Ciao
Valter

 anch'io, ma è meno banale di quanto possa sembrare...
Certo che è meno banale di quanto sembra.  Come già detto, esistono
algoritmi appositi e infrastrutture hardware dedicate.  Il calcolo
parallelo è una branca precisa dell'informatica.


 
La domanda ha una sola, unica risposta: non e' possibile saperlo.
Chiunque con un minimo di professionalita' non si azzarderebbe a darti 
delle stime, sia pur a spanne.
I fattori in gioco sono talmente vari che potresti persino ottenere 
delle performance peggiori dell'originale.
Improbabile, ma possibile.
Oltre all'infinita' di calcoli, il fattore memoria potrebbe essere molto 
importante.
--
Roal Zanazzi

 grandi linee in quanto potrebbero essere molti i fattori in gioco)?
Aggiungerei la possibilita' di modificare la priorita' ( e quindi la 
velocita') dell'eseguibile con:
Priority:=GetPriorityClass(GetCurrentProcess());
SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS);
// Calcolo
....
SetPriorityClass(GetCurrentProcess(),Priority);
Puoi anche tentare con la massima priorita' mettendoci: 
REALTIME_PRIORITY_CLASS, bloccando il mouse e altro del S.O.
Ciao Giorgio

 velocita') dell'eseguibile con:
[...]
Ha un'influenza pressoché nulla sulla velocità delle operazioni effettuate
nell'unità di tempo.  Cambiare la priorità di un processo/thread ha senso
se si vuol dare più "reattività" al processo/thread, non se si vuole che
proceda più velocemente...


 proceda più velocemente...
Evidentemente non hai mai effettuato delle prove.
Anche nell'Help e' spiegato che maggiore e' la priorita' di un Thread o 
Processo e maggiore e' il "CPU Time" dedicato al processo.
Giorgio

Processo e maggiore e' il "CPU Time" dedicato al processo.
Conosci il significato dei termini ? si parla appunto di "CPU Time",
ovvero il tempo processore che viene assegnato al processo, il che NON
SIGNIFICA AFFATTO che il processo acquisti velocità di calcolo! ma
solo che il processo scala come priorità al punto da avere più tempo
processore per lui.  Questo significa che l'incremento delle
performance, specie su una macchina su cui è eseguito quell'unico
processo, potrebbe essere REALMENTE insignificante.

 calcolo.
Voglio provare a seguire questa strada restando nell'ambiente Delphi. Può 
darsi che non ne ricaverò nulla ma se non altro imparerò 
q.sa
 di più.
Supponiamo che abbia un server dove girerà l'applicazione...l'idea potrebbe 
essere quella di predisporre un client da installare su altre n macchine che 
ricevano i dati da elaborare e restituiscano al server i risultati (nel 
frattempo il server potrebbe a sua volta elaborare la sua parte di dati). 
Una sorta di SETI. Vedo in rete che esistono già software idonei alla 
parallelizzazione ma data la semplicità delle operazioni mi chiedevo se non 
fosse meglio scriversi il server ed il client in Delphi. Per assurdo si 
potrebbe arrivare a chiedere la collaborazione di amici collegati 
costantemente in rete ed utilizzare anche le loro macchine (un SETI baby, 
per l'appunto).
Ci studio un pò, ma se volete comunicatemi pure qualunque cosa vi passi per 
la testa...
Ciao
Grazie
Valter

 la testa...
Ci puoi provare.  Un sistema del genere non è complesso da realizzare,
devi solo studiare bene il protocollo di comunicazione tra i vari peer
della tua rete.


 della tua rete.
un input, dato che ti è chiaro il progetto: tempo addietro mi ero 
sbizzarrito con ICS di Piette, riuscendo a gestire bene tutte le operazioni 
con i socket. Mi suggerisci componenti di terze parti o ritieni esaustivi 
quelli forniti con D7?
Grazie
Valter

 quelli forniti con D7?
Anche gli Indy (ver. 9) vanno bene.


 esaustivi quelli forniti con D7?
Se hai bisogno di qualche input sucome funzionano simili framework,
guarda qui:
Berkeley Open Infrastructure for Network Computing
http://boinc.berkeley.edu/
E più precisamente: 
http://boinc.berkeley.edu/impl_notes.php
Qui invece trovi un framework sviluppato in Delphi:
http://gpu.sourceforge.net/faq.php
