Newsgroup: it.comp.lang.visual-basic
Titolo: [?] dimensione variabili

in un ciclo tipo
    With rs
        While Not .EOF
            For j = 0 To .Fields.Count - 1
j conviene dichiararla byte o integer ?
grazie, a.

 j conviene dichiararla byte o integer ?
Direi Integer. Non credo che VB abbia delle ottimizzazioni sui dati di tipo
byte, e poi ormai con i processori a 32 bit non c'è più differenza.
In ogni caso, se il tuo problema è quello di ottimizzare la velocità,
risparmi di sicuro più tempo se metti il valore di (.Fields.Count - 1) in
una variabile così VB non lo ricalcola ogni volta per vedere se è  ora di
uscire dal ciclo.
Setta il valore della variabile direttamente prima di entrare nel While,
tanto è improbabile che il tuo recordset cambi numero di campi mentre cicli
fra i suoi record ;-)
Ciao
*Roby*

 j conviene dichiararla byte o integer ?
Long
Ciao

 fra i suoi record ;-)
a meno che la tabella non abbia due schede in tutto,
questo non e' detto. non conosci i miei polli :)

 Long
long ?

 ha scritto nel messaggio
news:9pfh46$hl89i$1...@ID-51318.news.dfncis.de...


 j conviene dichiararla byte o integer ?
Su processori a 32 bit utilizzare gli interi a 32 bit e' sempre più veloce
(non so però quanto possa essere il risparmio). Quindi Long.
Ciao.

 (non so però quanto possa essere il risparmio). Quindi Long.
intanto, grazie a roby, zanna, eros e h.p.l.
ho provato con un po' di codice. la tabella (con parecchi campi) ha 40k
righe, il db e' 100 mb, i txt generati 75.
BYTE: 40432 -- 34,50
INT: 40432 -- 28,40
LONG: 40432 -- 29,83
BYTE: 40432 -- 29,95
INT: 40432 -- 28,98
LONG: 40432 -- 29,80
BYTE: 40432 -- 29,55
INT: 40432 -- 28,70
LONG: 40432 -- 30,10
codice qui sotto. forse si potrebbe provare con una routine di calcolo,
senza ricorso al disco.
ciao, a.
Option Explicit
Dim fnum As Integer, fname As String
Dim db As Database, rs As Recordset
Private Sub cmdbyte_Click()
    Dim time1: time1 = Timer
    Dim j As Byte, f As Byte, cnt As Long
    Set rs = db.OpenRecordset("persone")
    fnum = FreeFile
    fname = App.Path & "\byte.txt"
    Open fname For Output As #fnum
    With rs
        f = .Fields.Count - 1
        While Not .EOF
            cnt = cnt + 1
            For j = 0 To f
                If Not IsNull(.Fields(j)) Then Print #fnum, .Fields(j)
            Next
            .MoveNext
        Wend
    End With
    Close #fnum
    rs.Close: Set rs = Nothing
    Text1 = Text1 & vbCrLf & _
        "BYTE: " & cnt & " -- " & Format(Timer - time1, "###,##0.00")
End Sub
Private Sub cmdint_Click()
    Dim time1: time1 = Timer
    Dim j As Integer, f As Integer, cnt As Long
    Set rs = db.OpenRecordset("persone")
    fnum = FreeFile
    fname = App.Path & "\int.txt"
    Open fname For Output As #fnum
    With rs
        f = .Fields.Count - 1
        While Not .EOF
            cnt = cnt + 1
            For j = 0 To f
                If Not IsNull(.Fields(j)) Then Print #fnum, .Fields(j)
            Next
            .MoveNext
        Wend
    End With
    Close #fnum
    rs.Close: Set rs = Nothing
    Text1 = Text1 & vbCrLf & _
        "INT: " & cnt & " -- " & Format(Timer - time1, "###,##0.00")
End Sub
Private Sub cmdlong_Click()
    Dim time1: time1 = Timer
    Dim j As Long, f As Long, cnt As Long
    Set rs = db.OpenRecordset("persone")
    fnum = FreeFile
    fname = App.Path & "\long.txt"
    Open fname For Output As #fnum
    With rs
        f = .Fields.Count - 1
        While Not .EOF
            cnt = cnt + 1
            For j = 0 To f
                If Not IsNull(.Fields(j)) Then Print #fnum, .Fields(j)
            Next
            .MoveNext
        Wend
    End With
    Close #fnum
    rs.Close: Set rs = Nothing
    Text1 = Text1 & vbCrLf & _
        "LONG: " & cnt & " -- " & Format(Timer - time1, "###,##0.00")
End Sub
Private Sub Form_Load()
    Set db = OpenDatabase("db1")
End Sub


Guarda che hai una "finestra" che ti fa corrente :PPP
Ciao



Non vorrei rompere le uova nel paniere, ma i risultati così ottenuti non
sono validi perchè Windoz esegue caching dei file aperti, ed anche se non ne
tiene in memoria i dati per raggiunta limiti, detiene i loro descrittori per
un più rapido accesso, senza contare le dll che carica e non scarica dalla
mem. Per questo, IMHO, si dovrebbe eseguire ogni routine a computer "pulito"
(appena acceso) per avere dei dati confrontabili.
Spero di non aver capito male...
Cmq i Long sono il tipo di dati più veloce.
Ciao,
--
V. Roccasalvo
email:
vrocca....@iname.nos_pam.com
Pregasi rimuovere nos_pam prima di scrivere

 Cmq i Long sono il tipo di dati più veloce.
ciao vincenzo, quello che dici e' piu' che corretto. ci avevo pensato, e per
questo dicevo che conviene provare una routine p.e. di grafica. questa
macchina ha abbastanza ram da tenersi in memoria il db e i 3 txt tutti
insieme, e la cache prob ha giocato (il timing del primo ciclo imho sarebbe
stato decisamente piu' alto anche se usavo il long, ma non ho voglia di
stare li' di nuovo :). ma sono condizioni _non_ irripetibili con i pc in
circolazione. e il ciclo viene eseguito un numero di volte discretamente
alto (21 campi * 40k record) da non poter _non_ tener conto dei risultati,
considerando l'uso tipico di vb. il long e' _probabilmente_ piu' veloce in
assoluto e _in linea teorica_, ma non mi sembra ci sia un abisso. se
qualcuno ha voglia di provare con la grafica, mi farebbe piacere.
ciao, a.

 ciao, a.
Forse non ci sono abissi perchè VB esegeu il padding delle variabili (se non
ricordo male), quindi allinea tutto a 32 bit e poi estrae i risultati
riducendo i bit (si qualcosa del genere).
Ciao :-)))))))))))))))


 riducendo i bit (si qualcosa del genere).
Se è così allroa perchè genera sempre overflow? allora è proprio cattivo :)

 ha scritto

fa finta di essere un linguaggio tipizzato.
roal fermo li', lo so che stavi per togliere "tipizzato".


non viene più calcolato il valore viene messo in un registro :)
ste cose le insegnano ai pivelli sulla programmazione :)

 ste cose le insegnano ai pivelli sulla programmazione :)
Porca l'oca, ci hai ragione.
Ho fatto una prova stupida:
Private Sub Command1_Click()
   Dim a As Integer
   Dim r As Integer
   a = 4
   For r = 1 To a - 1
      a = 2
   Next
   MsgBox "Valore di a =" & a & ". Valore di r = " & r
End Sub
Quando R esce dal ciclo vale 4 e non 2 come avrei detto io. Ottimo, ho
imparato una cosa nuova.
Ciao
*Roby*
P.S.
Hai ragione a dire che lo insegnano ai pivelli, perchč a me non lo hanno
insegnato. Mi sono passato tutti i basic da quello del Vic 20, passando per
il   GWBasic, QuickBasic, Professional Basic e per 3 versioni di VB, e non
ho mai ricontrollato se avevano modificato il comportamento del ciclo.
Grazie a te ora lo so. :-)

 j conviene dichiararla byte o integer ?
Long... Almeno ti eviti i disallineamenti se VB non dovesse ottimizzare
bene.
Eccezione: non ho controllato il tipo di rs.fields.count: se e' integer e
non long e' meglio dichiararla integer, eviti un CWD per ciclo... Risparmi
forse un ciclo macchina :P
Ciaotutti,
*


Se fa il padding funziona cosi':
long long = 64 bit
integer long = 64 bit
integer integer long = 64 bit
byte long = 64 bit
byte integer long = 64 bit
byte byte integer long = 64 bit
byte integer integer long = 96 bit
ecc...
Ciaotutti,
*

 wrote in message
9pffaj$hvfav$1...@ID-51318.news.dfncis.de...

per come la vedo io... conviene non dichiararla proprio... ::))))
MarioH

 per come la vedo io... conviene non dichiararla proprio... ::))))
piuttosto che
    as variant
preferirei
    as labrador.

 Ho fatto una prova stupida:
si però te ne do' un'altra ..
non è sempre vero soprattutto se lavori in altri linguaggi :))
ciao bello

 wrote in message
hbPu7.18807$0Y2.2...@news.infostrada.it...

Veramente, "pivello", il valore del membro "To" del for, viene calcolato
solo all'entrata nel ciclo.
E non ad ogni ciclo.
Ciao

 E non ad ogni ciclo.
si vede che hai capito quello che dicevo :)))

 
Allora tantovale di tipo Long.
-- 
Samuele Battarra
prova il mio newsreader:
http://digilander.iol.it/battarsa/programmi/news/

 
Anche perchè la memoria è a 32 bit e non guadagni spazio per via
dell'allineamento.
Cioè un numero a 32 bit viene memorizzato in una locazione a 32 bit.
Un numero a 16 bit viene memorizzato sempre in una locazione a 32 bit
lasciandone 16 inutilizzati, idem per i numeri a 8 bit.
I vecchi compilatori per dos permettevano di decidere se attivare o meno
l'allineamento. In caso negativo si aveva una riduzione della memoria
occupata a scapito però della velocità. Infatti essendo la memoria a 32
bit posso leggere solo 32 bit per volta, se una locazione contiene due
valori a 16 bit, devo leggerli entrambi e poi fare un and per isolarli.
Poi può capitare che dopo un valore a 16 bit che occupa mezza locazione,
ce ne sia uno a 32 che viene così memorizzato metà in una locazione e
metà in un altra: doppio lavoro per estrarla, devo estrarre due valori
a 16 bit come nel caso precedente e poi fonderli!


Franco ha scritto:

Che non viene più calcolato è vero (basta fare una prova),
che venga messo in un registro... se fosse stato C avrei detto quasi
sicuramente si, trattandosi di VB non ci giurerei. 


 
Me.PolemicMode = True
Un bel "-- " prima della firma no??
Scusa se bacchetto solo te quando dovrei farlo con tutti,
prometto che appena mi capita lo faccio anche con gli altri :-)


> Un bel "-- " prima della firma no??
E' che non c'e' la firma :P
Il mio ciaotutti lo scrivo a mano :P
Ciaotutti,
*

 
Tutte le volte???
Quando dovevo scrivere la firma a mano era già molto
se usciva fuori un ciao.


 
Tutte le volte???
Quando dovevo scrivere la firma a mano era già molto
se usciva fuori un ciao.
-- 


 
Tutte le volte???
Quando dovevo scrivere la firma a mano era già molto
se usciva fuori un ciao.
-- 



Beh dopo un po' diventa automatico :)
Alle volte pero' mi scappa un "Caiotutti" o un "è" al posto di *... Vedi
piu' sopra (sotto?) un mio ris-post dopio con reply di j (sempre puntuale
:PP)...
All'inizio mi firmavo "Ciaotutti, Alessandro", poi ho iniziato a ridurre (un
po' anche per fare invidia a zio pal, lo confesso :PP)...
Ciaotutti,
*