Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 20
  1. #1

    CONSIDERAZIONE: output asp

    bene..
    una discussione seria (non che nessuno sia escluso intendo... però vorrei giungere a delle conclusioni chiare e concise)

    PREGO TUTTI DI RISPONDERE SOLO !!!DOPO!!! AVER LETTO TUTTO IL POST

    --------------------------------------------------
    --------------------------------------------------

    DEFINIZIONI:
    (così non scrivo 10 righe ogni volta che li nomino
    non sono vere definizioni rigorose, anzi, ma mi servono per essere più chiaro in quello che segue)

    --------------------------------------------------

    buffertrue
    la pagina viene inviata al client solo quando è stata terminata l'elaborazione

    --------------------------------------------------

    bufferfalse
    la pagina viene inviata al client man mano che l'elaborazione va avanti...

    --------------------------------------------------

    spaghettistyle
    stampare HTML e OUTPUT asp mischiandolo

    esempio di una pagina completa:
    codice:
    <% response.write "io " %>
    sono
    <% response.write " simone" %>
    risultato html:
    codice:
    io sono simone
    --------------------------------------------------

    writestyle
    stampare solo OUTPUT asp usando in pratica un unico tag <% %>

    esempio di una pagina completa:
    codice:
    <% response.write "io sono simone" %>
    risultato html:
    codice:
    io sono simone
    ---------------------------------------------------
    ---------------------------------------------------

    LA QUESTIONE:

    siccome mi sto addentrando nel magico mondo dell'ottimizzazione ho cercato di capire (spinto dall'utilizzo della classe CSTRINGBUILDER di baol) come fare a migliorare la velocità per l'output.

    ciò che sto sviluppando è la nuova versione del mio forum (che finalmente sarà pubblica).

    la mia idea iniziale era quella di non lavorare spaghettistyle (vedi definizioni) ma di lavorare tutto writestyle

    il motivo è che ho notato che ad esempio lo snitz lo fa, e così ad occhio mi sembra una via migliore

    il fatto che il parser ASP non si trovi di mezzo pezzi di html mischiati a tag asp mi sembra che possa dare prestazioni migliori

    così mi sono deciso e ho fatto alcuni test

    ---------------------------------------------------
    ---------------------------------------------------

    I TEST:

    2 pagine
    4 test

    pagina 1 [writestyle + bufferfalse o buffertrue]
    codice:
    <%@ Language=VBScript %>
    <%
    option explicit
    
    response.buffer = true 'oppure FALSE per il secondo test
    
    dim i,StartTime,EndTime,TimeIt
    
    StartTime = timer
    
    for i=0 to 100000
    	response.write "aaa
    "
    	response.write "bbb
    "
    next
    EndTime = timer
    TimeIt = EndTime - StartTime
    response.write TimeIt
    
    %>

    pagina 2 [spaghettistyle + bufferfalse o buffertrue]
    codice:
    <%@ Language=VBScript %>
    <%
    option explicit
    
    response.buffer = true 'oppure FALSE per il secondo test
    
    dim i,StartTime,EndTime,TimeIt
    
    StartTime = timer
    
    for i=0 to 100000
    	%>aaa
    <%
    	response.write "bbb
    "
    next
    EndTime = timer
    TimeIt = EndTime - StartTime
    response.write TimeIt
    %>
    ---------------------------------------------------

    la prima pagina è lo stile STAMPO TUTTO L'HTML METTENDOLO DENTRO A DELLE STRINGHE ( "<html><head>....." ) e infilandoci ogni tanto in mezzo qualche variabile ASP (altrimenti che uso a fare asp :P)

    la seconda pagina è lo stile STAMPO LE VARIABILI ASP CON RESPONSE.WRITE e l'html fisso lo lascio fuori dai TAG ASP

    fin qui tutto chiaro? spero di si...

    --------------------------------------------------

    come seconda cosa mi sono chiesto se ha più senso impostare (dal punto di vista di prestazioni, perchè il motivo per cui a volte si usa il respose.buffer = false è chiaro a tutti [dare all'utente l'ouput mentre è generato... in alcuni casi è utile]) il buffer a true o false..

    quindi le due pagine le ho avviate in due modi
    col buffer = false e col buffer = true

    bene


    --------------------------------------------------
    --------------------------------------------------

    I RISULTATI DEI TEST:

    PAGINA1 / BUFFERTRUE (writestyle)
    0,1875 sec

    PAGINA1 / BUFFERFALSE (writestyle)
    62,26563 sec (non è uno scherzo!)

    PAGINA2 / BUFFERTRUE (spaghettistyle)
    0,109375 sec

    PAGINA2 / BUFFERFALSE (spaghettistyle)
    54,32813 sec


    le dimensioni di tutti gli output sono esattamente
    1.400.061 byte
    ovvero circa 1,4 MB


    differenza bufferfalse pagina1 - pagina2
    7,9375 sec

    differenza buffertrue pagina1 - pagina2
    0,078125

    --------------------------------------------------
    --------------------------------------------------

    CONCLUSIONE E DOMANDA:

    avrei previsto che la soluzione più veloce sarebbe stata senza dubbio WRITESTYLE + BUFFERFALSE

    invece la classifica delle più veloci è
    1. SPAGHETTISYLE + BUFFERTRUE
    2. WRITESTYLE + BUFFERTRUE
    3. SPAGHETTISYLE + BUFFERFALSE
    4. WRITESTYLE + BUFFERFALSE

    ottimo. ho scelto proprio la soluzione più lenta.

    dai test risulta che la soluzione più performante è senza dubbio la spaghettistyle con buffertrue

    l'avreste detto?
    considerazioni?
    è un test mal posto?
    san imente saluta

    * http://simonecingano.it *

  2. #2
    Il test è senza dubbio interessante.
    Anche io avrei scommesso sul cavallo sbagliato, ma non sull'ultimo.

    Il buffer true è notevolmente più veloce poichè abilita il caching di determinate operazioni, anche se rischia il collasso se l'output è eccessivamente pesante ed impiega troppe risorse.

    Senza dubbio non avrei però immaginato differenze così plateali.
    La spiegazione è quasi sicuramente riconducibile al fatto che il test agisce su un ciclo che fa sempre e solo una operazione.
    Il buffer true probabilmente è in grado di ottimizzare il ciclo.

    Quello che mi stupisce è lo spaghettistyle.
    Avrei certamente scommesso che il risultato sarebbe stato peggiore rispetto al resto.
    Mi chiedo se anche in questo caso non sia opportuno ripetere il test su un file più complesso per valutare più esecuzioni combinate.

  3. #3
    ho fatto un test con una pagina normale

    una versione SPAGHETTISTYLE e una versione WRITESTYLE
    in più nell'html ci ho infilato un centinaio di <%="qualcosa..."%> nello spaghetti e & "qualcosa..." &

    (non ci ho messo una stringa, ma un numero calcolato per appesantire un po' la pagina e non avere proprio 0 sullo spaghetti)

    per aumentare un po' il peso ci ho messo anche un ciclo da 100

    il risultato?

    SPAGHETTISTYLE
    0.156 sec

    WRITESTYLE
    58.8

    ------------------------

    ok.
    è anche vero che il contenuto sono 500KB ed è difficile che una pagina di html pesi così tanto (è una pagina da 5kb valida, moltiplicata col ciclo)

    quindi ho fatto un ciclo da 4 (pagina da 20kb, credibilissima)

    il risultato?

    SPAGHETTISTYLE
    0

    WRITESTYLE
    0,03125

    (con buffer = false SPAGHETTI 0 e WRITE 0,156)

    -----------------------

    risultato HTML identico.
    stesse elaborazioni ASP
    metodo di output differente.
    vince spaghetti

    ora l'ultimo test è utilizzando la classe di BAOL per l'output di stringhe
    san imente saluta

    * http://simonecingano.it *

  4. #4
    ptobabilmente lo spaghetti style è piu veloce perchè non è asp dipendente ma viene interpretato/scritto dall'interprete html del browser?

    o cmq qualcosa di simile?

  5. #5
    Originariamente inviato da santino83
    ptobabilmente lo spaghetti style è piu veloce perchè non è asp dipendente ma viene interpretato/scritto dall'interprete html del browser?

    o cmq qualcosa di simile?
    calma.
    le pagine vengono interpretate SERVER SIDE
    poi mandate CLIENT SIDE al browser

    quindi il browser in questa discussione non c'entra
    san imente saluta

    * http://simonecingano.it *

  6. #6
    ho effettuato il test con la classe di baol (versione ADO) (il quale contributo in questa discussione è caldamente richiesto :P)

    TEST 4 cicli (elaborazione di 20kb)
    SPAGHETTI: 0
    WRITE: 0.03
    BAOL: 0.03

    TEST 100 cicli (elaborazione di 500kb)
    SPAGHETTI: 0.156 sec
    WRITE: 58.80 sec
    BAOL: 0.59375

    direi che la storia non cambia...
    anche con 500 kb, il fatto che l'html non passi dalle stringhe ma venga usato direttamente senza interpretazione è la soluzione migliore

    la spiegazione quindi è inevitabilmente questa.

    ---------------------------------------

    rimane anche il fatto che se si devono concatenare molte stringhe la classe di BAOL batte schifosamente un sistema come

    STRINGA = STRINGA & "qualcosa"

    ma questo era indubbio
    san imente saluta

    * http://simonecingano.it *

  7. #7
    Utente di HTML.it L'avatar di kluster
    Registrato dal
    Jul 2003
    Messaggi
    1,288
    indubbiamente si impara sempre qualcosa grazie ai tipi creativi .

    Non mi metto a fare test a quest'ora perchè sono impelagato ma come ultima analisi sarebbe da testare il
    <script language="vbscript" runat="server"> invece dei tag <% %> per sapere di quanto cambia.

  8. #8
    Utente di HTML.it L'avatar di Baol74
    Registrato dal
    Jul 2002
    Messaggi
    2,004
    Cos'è la versione ado della mia classe? Le prestazioni diminuiscono se crei un oggetto come AdoDb.Stream...

    Comunque.
    Prova la mia classe con Buffer = False

    Io credo che usare cStringBuilder oltre avere delle prestazioni apprezzabili (mi riferisco al TEST 100 cicli) consente come ti dicevo di fare una cosa che lo spaghettistyle o il writestyle non consentono : il caching .

    Inoltre hai vantaggi sia nella pulizia del codice, sia nella possibilità di estendere la classe con altre funzioni.

    SpaghettiStyle mi ha stupito!
    Il buffer=False con prestazioni pessime no.

  9. #9
    avevo gia' letto del mixed mode piu' veloce dell'asp puro. se ritrovo l'articolo ve lo posto.

    cmq, al solito: piedi per terra. differenze eclatanti le si trovano su cicli mostruosi, non credo su pagine normali. se le differenze sono risibili, userei comunque l'asp puro per leggibilità e manutenibilità del codice. siamo pero' nel campo delle preferenze personali: fate quindi come vi pare

  10. #10
    Originariamente inviato da Baol74
    Cos'è la versione ado della mia classe? Le prestazioni diminuiscono se crei un oggetto come AdoDb.Stream...
    ho due versioni
    una che usa array e una che usa adodb.stream
    le ho modificate leggermente per renderle "compatibilI"
    ovvero ho chiamato le funzioni allo stesso modo.

    [QUOTE]Originariamente inviato da Baol74
    Comunque.
    Prova la mia classe con Buffer = False
    Originariamente inviato da Baol74
    Io credo che usare cStringBuilder oltre avere delle prestazioni apprezzabili (mi riferisco al TEST 100 cicli) consente come ti dicevo di fare una cosa che lo spaghettistyle o il writestyle non consentono : il caching .
    infatti il mio non voleva essere un test comparativo
    il meccanismo della tua classe è da utilizzare per scopi diversi.
    è che m'è venuta la voglia di provare cmq...

    Originariamente inviato da Baol74
    SpaghettiStyle mi ha stupito!
    Il buffer=False con prestazioni pessime no.
    allora è stata una cosa utile.
    perchè mi sembra che tutti abbiamo avuto dello stupore da questa cosa
    san imente saluta

    * http://simonecingano.it *

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.