Domanda

Qual è la differenza - prestazioni-saggio - tra la lettura da una presa 1 byte per volta vs lettura grande pezzo

?

Ho un'applicazione C ++ che ha bisogno di tirare le pagine da un server web e analizzare la riga di pagina ricevuta per riga. Attualmente, sto leggendo 1 byte alla volta fino a che incontro è raggiunto un CRLF o il massimo di 1024 byte.

Se la lettura in grande pezzo (ad esempio 1024 byte alla volta) è molto meglio performance, qualsiasi idea su come ottenere lo stesso comportamento ho attualmente (cioè in grado di memorizzare ed elaborare 1 linea html alla volta -? fino a quando il CRLF senza consumare ancora i byte successivi)

EDIT:

Non posso permettermi troppo grandi buffer. Sono in un budget codice molto stretto come l'applicazione è utilizzata in un dispositivo embedded. Preferisco mantenendo solo buffer di dimensioni fisse, preferibilmente di tenere una linea html alla volta. Questo rende la mia analisi e per altre lavorazioni facile come sono da ogni volta provo ad accedere al buffer per l'analisi, posso supporre che sto elaborazione di una linea HTML completo.

Grazie.

È stato utile?

Soluzione

Se si sta leggendo direttamente dalla presa, e non da una rappresentazione superiore livello intermedio che possono essere memorizzati, quindi senza possibilità di dubbio, è solo meglio leggere completamente i 1024 byte, metterli nella RAM in un buffer , e poi analizzare i dati dalla RAM.

Perché? Lettura su un socket è una chiamata di sistema, e provoca un cambio di contesto su ogni lettura, che è costoso. Per saperne di più su di esso: IBM Tech Lib: spettacoli presa Boost

Altri suggerimenti

Non posso commentare su C ++, ma da altre piattaforme - sì, questo può fare una big differenza; in particolare nella quantità di interruttori del codice deve eseguire, e il numero di volte che è necessario preoccuparsi della natura asincrona dei flussi ecc.

Ma il vero test è, naturalmente, per il profilo it. Perché non scrivere un'applicazione di base che sforna attraverso un file arbitrario utilizzando entrambi gli approcci, e testarlo per alcuni file tipici ... l'effetto è di solito sorprendente, se il codice viene IO legato. Se i file sono di piccole dimensioni e la maggior parte del vostro tempo di esecuzione applicazione è speso di elaborazione i dati una volta che è in memoria, non si è probabile notare alcuna differenza.

Per prima e più semplice:

cin.getline(buffer,1024);

In secondo luogo, di solito tutto IO è tamponato in modo che non c'è bisogno di preoccuparsi troppo

In terzo luogo, processo CGI inizia di solito costa molto di più quindi l'elaborazione di ingresso (a meno che non è enorme file) ... Così si può solo non pensarci.

Buongiorno,

Uno dei grandi successi di prestazione di farlo un byte alla volta è che il contesto sta andando di volta in volta dall'utente sistema più e più volte. E sopra. Non è efficiente a tutti.

afferra una grossa fetta, in genere fino a una dimensione MTU, è misurabile più efficiente.

Perché non eseguire la scansione del contenuto in un vettore e iterare oltre che guardare fuori per \ n di di separare il vostro input in linee di ingresso web?

HTH

applausi,

Non state leggendo un byte alla volta da una presa, si sta leggendo un byte alla atime dal sistema I / O C / C ++ I, che se si utilizza CGI avrà alreadety tamponata tutta l'input dal zoccolo. L'intero punto di buffer di I / O è quello di rendere i dati disponibili al programmatore in un modo che è conveniente per loro di elaborare, quindi se si desidera elaborare un byte alla volta, andare avanti.

Modifica Su riflessione, non è chiaro dalla tua domanda se si sta implementando CGI o semplicemente utilizzarlo. Si potrebbe chiarire questo inviando un frammento di codice che indica come è attualmente leggere leggere quel singolo byte.

Se stai leggendo direttamente alla presa, allora si dovrebbe semplicemente leggere l'intera risposta al GET in un buffer e poi elaborarlo. Questo ha numerosi vantaggi, tra cui le prestazioni e la facilità di codifica.

Se si linitted ad un piccolo tampone, quindi utilizzare algoritmi tampone classici come:

getbyte:
   if buffer is empty
      fill buffer
      set buffer pointer to start of buffer
   end
   get byte at buffer pointer
   increment pointer

È possibile aprire il file di socket descritpor con la funzione fdopen (). Poi si è tamponata IO in modo da poter chiamare fgets () o simili su quel descrittore.

Non c'è differenza a livello di sistema operativo, i dati vengono bufferizzati comunque. L'applicazione, tuttavia, deve eseguire più codice di "leggere" i byte uno alla volta.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top