velocizzare VB6

[NS-1]

ho tra le mani un prog fatto in VB6 e ha un problema (solo uno?)...
tutto il corpo della programmazione è associato ad un unico tasto che una volta premuto consigla di metterti comodo e guardare la tv per un quarto d'ora...

come posso velocizzarlo senza rifare tutto da zero?

acquisisce unicamente dei dati da files esterni e salva delle immagini su disco...

[LoryOne]

Boh, non saprei.
Non centra nulla comunque il fatto che venga associata tutta l'operazione alla pressione di un unico tasto, anzi, può essere ancora più veloce della stessa operazione splittata su più sub/functions.

Ci sono alcuni accorgimenti da tener presente:
1) i tipi di dati Long sono più veloci da gestire rispetto ai tipi di dati Integer (almeno su sistemi a 32 bit)
2) Utilizzare i tipi di dati Byte invece di Integer qualora il loro valori vada da 0 a 255
3) i tipi di dati variant o currency sono da evitare come la peste
4) Aggiungere '$' a tutte le funzioni che agiscono su tipi stringa.Il valore restituito, in questo modo, non è di tipo variant
5) Utilizzare il più possibile i cicli for...next al posto dei vari while...wend o do...loop
6) Next al posto di Next [nome variabile] risulta essere più veloce
7) Utilizzare ChrW al posto di Chr$
8) Ricordarsi sempre che VB gestisce le stringhe in UNICODE, non ANSI, quindi è molto più lento rispetto ad altri compilatori.
7) Quando si ha a che fare con manipolazione di stringhe , utilizzare ArrByte=strconv(String,vbFromUnicode), cioè utilizzare un array di byte, così come il ben noto char stringa[] in C.
In questo modo si tratterà la stringa in ANSI.
9) Anche VB utilizza i puntatori:
StrPtr,VarPtr ed ObjPtr
Non è possibile ricavare il valore di un puntatore se non con l'implementazione della API CopyMemory.
L'utilizzo di tali funzioni fornisce solo l'indirizzo in memoria, non il valore della variabile

cos'altro dire ?
Dovrei dare un'occhiata al codice

Pscusate l'italiano penoso ma spero di essermi fatto capire

[NS-1]

grazie mille,
così a occhio ci sono almeno 2 accorgimenti da sistemare...

appena possibile ti faccio sapere...

Ns-1

[LoryOne]

Di niente, figurati.
Per quanto riguarda i puntatori comincerò a scrivere qualcosa su come implementarli in VB e lo posterò in coda a questo post.

Chissà che qualcuno possa rimanere stupito all'idea che persino VB possa utilizzare i puntatori

[NS-1]

..dovrei avere in giro qualcosa sui puntatori in VB...
se trovo, posto!

[NS-1]

scusa LoryOne ma...... L'AVATAR?

[LoryOne]

non sono tipo da AWATER

[LoryOne]

Prima di cominciare a vedere l'utilizzo dei puntatori in VB è necessario aver ben chiaro che, indipendentemente dal linguaggio utilizzato e di conseguenza dall'utilizzo delle funzioni messe a disposizione dallo stesso linguaggio per la manipolazione dei dati, prima di elaborare qualunque tipo di dato il computer ha bisogno di immagazzinarlo in memoria dalla quale prelevarlo, elaborarlo ed infine restituirlo come risultato di un'operazione.

La memoria di un computer altro non è (semplificando il più possibile ovviamente) che una serie di celle affiancate una all'altra atte a contenere un certo quantitativo di dati suddivisi in # di celle le cui coordinate sono x ed y (o riga e colonna).

Ogni dato, quindi, deve essere contrassegnato da un "marcatore" che lo identifichi in maniera univoca e che dia la possibilità di fare accesso diretto ad esso senza leggere i precedenti elementi. Il "marcatore" è comunemente chiamato indirizzo (o address) ed è suddiviso in Segmento ed Offset.

Quando si parla di puntatori, si parla sempre di accesso diretto alla memoria.
Chiunque abbia familiarità con i puntatori sa benissimo che una variabile dichiarata di questo tipo è al tempo stesso sia un valore effettivo (*) sia una locazione di memoria (&).
Fatta questa doverosa premessa, si può procedere con l'utilizzo dei puntatori in Visual Basic.

In VB ci sono 3 istruzioni non riportate nella guida che consentono ad un programmatore di utilizzare i puntatori qualora sia fondamentale la velocità di esecuzione di una routine di manipolazione di dati.
Queste tre istruzioni sono StrPtr(), VarPtr() e ObjPtr() rispettivamente: StringPointer, VariablePointer ed ObjectPointer. Tutte e tre forniscono la LOCAZIONE IN MEMORIA del dato al quale puntano, NON il dato stesso.

Nelle passate versioni di VB, l'operazione di accesso alla variabile, modifica e ricavo del dato modificato poteva essere implementato in questo modo:

Dim s As String 's è una variabile di tipo Stringa
s="Maria"
Debug.Print VarPtr(s) 's si trova alla locazione xxxxxxx
Debug.Print VarPtr(ByVal s) 'alla locazione xxxxxxx si trova "Maria"

Nelle recenti versioni di Vb, tale metodologia non è più valida.
E' necessario utilizzare la API CopyMemory (o meglio MoveMemory) così dichiarata:
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" _
(ByRef pDst As Any, ByRef pSrc As Any, ByVal ByteLen As Long)

Tale funzione sposta un certo quantitativo di byte (ByteLen) da una locazione di partenza (pSrc) ad una di destinazione (pDst).
A prima vista il tutto risulterebbe piuttosto semplice in quanto le locazioni di partenza e di destinazione, nonchè il quantitativo di byte da spostare (Istruzioni Len() o LenB()), alla luce di quanto esposto poco sopra non dovrebbe destare alcun problema.

Sfortunatamente in VB non è tutto oro ciò che luccica ed i primi problemi si riscontrano nella manipolazione delle stringhe.
Vb gestisce internamente le stringhe di testo in formato UNICODE, non ANSI, quindi ogni singolo carattere costituente la stringa occuperà 2 byte in memoria.
Con s="Maria", i caratteri in memoria verranno mappati in questo modo:

77 0 97 0 114 0 105 0 97 0

Il quantitativo di memoria utilizzato sarà pertanto 2 x Len(s) o più semplicemente LenB(s).
Poichè qualunque tipo di dato è gestito dal computer come un numero, ogni carattere componente la stringa di testo verrà considerato pari al suo codice ASCII.
La sequenza numerica verrà pertanto interpretata dal computer nel modo seguente:
M si trova alla posizione di partenza + 0 byte
a si trova alla posizione di partenza + 2 byte
r si trova alla posizione di partenza + 4 byte
i si trova alla posizione di partenza + 6 byte
a si trova alla posizione di partenza + 8 byte

Se si volesse rendere maiuscola la xesima lettera della stringa s, tale operazione dovrebbe essere eseguita nel modo seguente:

s="Maria"
'Voglio modificare il secondo elemento della stringa.
x=2
'Effettuo la modifica facendo accesso diretto alla memoria.
CopyMemory ByVal (StrPtr(s) + x), 65, 1
Debug.Print s

Il risultato dell'operazione è il seguente: s="MAria"
Vediamo di capire cosa è avvenuto:
Ho spostato 1 byte (la lettera "A" ha codice ASCII 65) dalla locazione di memoria puntata da StrPtr alla locazione di memoria puntata da StrPtr + 2 byte.
Perchè ByVal ?
ByVal serve a trasformare una sequenza UNICODE in una ANSI un attimo prima di restituire il dato.
(Ricordatevi che, come riportato poco prima, VB gestisce internamente le stringhe in UNICODE)

Una stringa altro non è che una sequenza di caratteri ed una sequenza di caratteri consecutivi altro non è che un array.
Vediamo ora un ulteriore utilizzo di CopyMemory per riempire un array di Byte.
Consideriamo nuovamente:
s="Maria"
Il primo passo sarà quello di definire un array di Byte abbastanza grande da contenere tutti i caratteri costituenti la stringa s:

ReDim Chars(0 To Len( S ) - 1) As Byte

Il secondo passo sarà quello di riempire materialmente l'array:
CopyMemory Chars(0), ByVal S, Len( S )

I più attenti si saranno accorti che se è vero che VB gestisce internamente le stringhe come UNICODE, l'array non è grande abbastanza per contenere l'intera stringa.
L'osservazione è più che giusta ma è necessario prestare attenzione a questo:
ByVal S
In questo modo la stringa verrà gestita da VB come ANSI con conseguente riduzione della memoria occupata a tutto vantaggio della velocità di esecuzione.
(Faccio notare che il tutto poteva essere risolto come Chars=StrConv(s,vbFromUnicode) ma con il metodo esposto pocanzi si guadagnano, anche se pochi, circa 10ms.)

In UNICODE sarebbe stato necessario pensare il tutto in questi termini:
S = "Maria"
ReDim Chars(0 To LenB( S ) - 1) As Byte
CopyMemory Chars(0), ByVal StrPtr( S ), LenB( S )

Resta un ultima cosa da vedere, ossia creare una stringa da un array di byte modificati opportunamente secondo l'esigenza del momento.
Anche in questo caso, VB si comporta ne più ne meno come C.
La prima cosa da fare è creare un buffer abbastanza grande da contenere l'intera sequenza di byte che costituiranno la stringa risultante:
s = Space$(UBound(Chars))
In seguito basterà la seguente istruzione:
CopyMemory ByVal StrPtr( S ), Chars(0), UBound(Chars)

Inutile far notare che il valore risultante sarà ANSI ma gestito internamente in UNICODE.

Fin'ora si è visionato il puntatore ad una stringa di caratteri (StrPtr) ma restano da vedere VarPtr ed ObjPtr.
Tratterò l'argomento successivamente anticipando che le cose, comunque, non cambieranno di molto rispetto ai concetti esposti fin'ora.

Per ora ciao ed alla prossima

[P8257 WebMaster]

LoryOne ha scritto:
Chissà che qualcuno possa rimanere stupito all'idea che persino VB possa utilizzare i puntatori

Bye

[LoryOne]

Lo sapevo !
Grande Web (Y)

[LoryOne]

Nella prima parte di questa mia piccola introduzione all'utilizzo dei puntatori in Visual Basic ho ritenuto essenziale evidenziare l'importanza di conoscere il quantitativo di byte da muovere da una locazione di memoria di partenza ad una locazione di memoria di destinazione per ottenere il risultato sperato; tale quantità, infatti, è strettamente legata alla tipologia di dato che si vuole manipolare (stringhe UNICODE oppure ANSI).

A molti è nota la potenza nonchè la pericolosità dell'utilizzo dei puntatori qualora l'uso improprio causi la sovrascrittura di aree estranee di memoria allocate in precedenza con conseguenti crash del sistema; risulta quindi obbligatoria la cautela da parte del programmatore che abbia necessità di ricorrere a tali scaltrezze.

Lasciamo ora perdere per un attimo la ormai collaudata StrPtr e passiamo a vedere come utilizzare VarPtr, ossia il VariablePointer.

Non credo sia utile soffermarsi sul risultato prodotto dal seguente script di esempio:

Dim a As Integer
a=1000
Debug.Print VarPtr(a)

mentre penso sia molto interessante spendere qualche parola su come gestire un array di elementi.
La domanda che sorge subito spontanea è:
Come gestisce VB a basso livello gli array ?
Ogni elemento di un array è identificato in modo univoco attraverso un descrittore. Quando si vuol fare accesso ad un elemento di un array è al suo descrittore che si punta.

Per spiegare meglio il concetto, pensiamo ad un piccolo programma che dato un array opportunamente dimensionato elimini un elemento dell'array slittando (shifting) verso il basso ogni elemento successivo all'indice specificato.
A molti sembrerà impossibile ma una volta definito il quantitativo di byte da muovere, il tutto si ridurrà a due sole istruzioni.

1) Per prima cosa definiamo il nostro array in questo modo:
'Creo un array di 6 elementi di tipo intero
Dim Object(0 To 5) As Integer

2) Popoliamo l'array:
Object(0)=100
Object(1)=1000
Object(2)=2000
Object(3)=3000
Object(4)=4000
Object(5)=5000

3) Supponiamo ora di eliminare il 3° elemento dell'array in modo da ottenre questo risultato:
Object(0)=100
Object(1)=1000
Object(2)=3000
Object(3)=4000
Object(4)=5000

Implementiamo il tutto, definendo una sub procedure in questo modo:

Sub Sub_DeleteArrayItem(ByVal Index As Long)
Dim LastItem As Long, Size As Long

LastItem = UBound(Objects)
'Ricavo il quantitativo di byte da spostare
Size = LenB(Objects(Index))
'Eseguo lo shifting verso il basso facendo accesso ai descrittori
'degli elementi dell'array
CopyMemory ByVal VarPtr(Objects(Index)), _
           ByVal VarPtr(Objects(Index + 1)), _
           (LastItem - Index) * Size

'Riduco di 1 elemento l'upperbound           
ReDim Preserve Objects(LastItem - 1)

Sebbene abbia commentato debitamente il codice, vorrei porre l'attenzione su 2 porzioni specifiche che costituiscono il punto principale dell'implementazione.
LenB() è il corrispettivo di sizeof() in C e non ha nulla a che vedere con Len().
(LastItem-Index)*Size è esattamente il quantitativo di byte da spostare dato dal prodotto del quantitativo di byte utilizzato da un intero moltiplicato per i rimanenti elementi dell'array.
Faccio notare che la procedura funziona anche su array di strutture (Type o Struct in C) in quanto LenB() ricava il quantitativo di byte utilizzato da ogni elemento della struttura.

Bene, ora resta da visionare ObjPtr.
Tratterò l'argomento successivamente anticipando che le cose, comunque, non cambieranno di molto rispetto ai concetti esposti fin'ora.

Per ora ciao ed alla prossima

[NS-1]

ti ringrazio per tutto,
ma è ancora lentissimo.....

[LoryOne]

I miracoli non si possono fare.
Quale procedura in particolare vorresti velocizzare ?
Pensi che in C risulti più veloce ?

Puoi provare e poi creare una dll da utilizzare in VB.Altro non so consigliarti.
Ripeto: Dovrei visionare il codice.

[LoryOne]

Eccoci arrivati all'ultima parte dell'introduzione sull'utilizzo dei puntatori in VB, ossia l' utilizzo del puntatore ad oggetti ObjPtr().

ObjPtr() obbedisce alle stesse regole che governano l'utilizzo del puntatore VarPtr() accennate nella precedente introduzione.
ObjPtr() viene spesso utilizzato quando si ha a che fare con collection di oggetti, in quanto fornisce un veloce indirizzamento ad ogni elemento incluso nella collection.

Non vi sono molti esempi di utilizzo pratico di questa funzione ma penso che uno qualsiasi degli script disponibili in rete non presenti particolari difficoltà nella comprensione del suo funzionamento.