Newsgroup: it.comp.lang.c++
Titolo: una funzione + veloce di cout???

a me servirebbe qualcosa + veloce di cout... sapete dirmi se c'č
un'altra funzione simile a cout ma + veloce?
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

"Yes Noo" ha scritto
: a me servirebbe qualcosa + veloce di cout... sapete dirmi se c'č
: un'altra funzione simile a cout ma + veloce?
Diciamo subito che cout non e` una funzione. E molto dipende da quello
che devi fare.
Comunque qualche alternativa puoi trovarla nel programma che segue:
#include <iostream>
#include <cstdio>
#include <ctime>
using namespace std;
int main()
{
  clock_t t0 = clock(), t1, t2, t3, t4, t5;
  for ( int j=0; j<1000; ++j )
    cout << "Hello world" << endl;
  t0 = clock() - t0;
  t1 = clock();
  for ( int j=0; j<1000; ++j )
    cout << "Hello world\n";
  cout << endl;
  t1 = clock() - t1;
  t2 = clock();
  for ( int j=0; j<1000; ++j )
    cout.write( "Hello world\n", 12 );
  cout << endl;
  t2 = clock() - t2;
  cout.sync_with_stdio(false);
  t3 = clock();
  for ( int j=0; j<1000; ++j )
    cout.write( "Hello world\n", 12 );
  cout << endl;
  t3 = clock() - t3;
  t4 = clock();
  for ( int j=0; j<1000; ++j )
    puts( "Hello world" );
  cout << endl;
  t4 = clock() - t4;
  t5 = clock();
  for ( int j=0; j<1000; ++j )
    fwrite( "Hello world\n", 12, 1, stdout );
  cout << endl;
  t5 = clock() - t5;
  cout << t0 << ' ' << t1 << ' ' << t2 << ' '<< t3 << ' '<<t4 << ' ' << t5;
  cin.get();
  return 0;
}
ciao
Massimo


"Vi or emacs? .....OpenOffice! =)"
 

   t5 = clock() - t5;
Se ci si trova in un ambiente Unix/posix compliant, e le performance sono
importanti  e' preferibile ricorrere a (2) write,(_write nei sistemi win32).

"Ivan Molella" ha scritto
: Massimo Valentini ha scritto:

Su linux ottengo dei risultati che sembrano contraddire quanto dici.
Per esempio ridirigendo lo stdout del programmino seguente su
/dev/null fwrite impiega la meta` del tempo di write, mentre se ridirigo
su un file nuovo fwrite impiega quasi un quarto del tempo di write. Su
consolle i tempi sono paragonabili.
#include <cstdio>
#include <ctime>
using namespace std;
#include <unistd.h>
int main()
{
  int const iterazioni = 150000;
  clock_t t5, t6;
  t5 = clock();
  for ( int j=0; j<iterazioni; ++j )
    fwrite( "Hello world ", 12, 1, stdout );
  fflush( stdout );
  t5 = clock() - t5;
  t6 = clock();
  for ( int j=0; j<iterazioni; ++j )
    write( 1, "Hello world ", 12 );
  fflush( stdout );
  t6 = clock() - t6;
  fprintf( stderr, "%d %d", t5, t6 );
  getchar();
  return 0;
}
Sei sicuro che saltare la bufferizzazione sia sempre conveniente?
Per non parlare delle complicazioni che sorgono se si deve formattare
l'output.
ciao
Massimo

 printf()
Ma chi l'ha detto che printf() e' piu' veloce di std::cout ??
Hai fatto dei test ? e poi mi chiedo: a che puo' servire
una funzione + veloce di std::cout ??


 un'altra funzione simile a cout ma + veloce?
Foooooooorse [OT] con le API sotto win32(se usi win32), ma non ne sono
sicuro
Ciao

 Su linux ottengo dei risultati che sembrano contraddire quanto dici.
 La fwrite e' una funzione che si pone leggermente al di sopra della SO,e visto
che non e' sviluppata da persone incapaci risulta dare ottime prestazioni.
 I tuoi test non sono attendibili: hai messo a confronto del codice ottimizzato
come quello di fwrite, con un codice per nulla efficiente.
siamo di fronte a 2 ordini di grandezza differenti:
tu nel ciclo della  write  hai un ritardo rispetto all fwrite  di
(PAGE_SIZE/sizeof "Hello World") * ((tempo chiamata a funzione) + (user
space/kernel space context switch time) ed in piu' il hai un'altro costo dato
dallo spostamento dei dati ogni volta dalla system cache al tuo buffer
locale,che probabilmente la fwrite non ha.
 La bufferizzazione va gestita applicativamente.
Nel caso di una stampa a video probabilmente la fwrite e' la scelta
consigliata, ma in un discorso + generale di ottimizzare i tempi di accesso a
disco  un buon utilizzo del sistema operativo puo risultare  la scelta migliore
Ivan Molella

"ho provato il tuo codice, e mi sono accorto che da dei risultati differenti
di volta in volta...
così ho messo il tuo codice in un loop for e l'ho fatto girare 20 volte e
stampare i tempi finali..
risultato: i valori sono tutti dello stesso ordine.
Non sono un bravo programmatore, anzi sto all'abc (sto studiando ora le
classi), ma quello che ho fatto mi sembra si commenti da solo...
zao, dan
PS. se c'è un motivo particolare per cui i valori sono sempre gli stessi, ma
gli operatori lavorano in tempi differenti, fammelo sapere: te l'ho detto,
sto all'abc.. ok? :-)

"Tjlt!®" ha scritto
:
: "ho provato il tuo codice, e mi sono accorto che da dei risultati
differenti
: di volta in volta...
: così ho messo il tuo codice in un loop for e l'ho fatto girare 20 volte e
: stampare i tempi finali..
In un ambiente multitasking i tempi di esecuzione sono influenzati
da numerose variabili per cui e` giusto fare delle medie. Se hai
modificato anche il calcolo dei tempi e con tempi finali intendi
la somma dei tempi parziali, va bene, altrimenti sarebbero i tempi
dell'ultimo ciclo.
Nota che io avevo aggiunto prima dell'ultimo ciclo che usa cout una
chiamata a
cout.sync_with_stdio(false);
il cui significato in un loop viene 'annacquato' se non le fai
corrispondere una chiamata a
cout.sync_with_stdio( true );
alla fine del relativo ciclo.
: risultato: i valori sono tutti dello stesso ordine.
: Non sono un bravo programmatore, anzi sto all'abc (sto studiando ora le
: classi), ma quello che ho fatto mi sembra si commenti da solo...
:
: zao, dan
:
: PS. se c'è un motivo particolare per cui i valori sono sempre gli stessi,
ma
: gli operatori lavorano in tempi differenti, fammelo sapere: te l'ho detto,
: sto all'abc.. ok? :-)
:
Diciamo che non vi e` necessita` di prestazioni elevate nella stampa
a video dei risultati di un programma: se sono tanti l'utente e` poi
costretto ad usare un altro programma (more or less) per visualizzare
l'output una pagina alla volta. Se sono pochi, non costituiscono mai
lo step limitante. Pero` potrebbero essere tanti ed essere salvati su
file mediante reindirizzamento dell'output.
Per vedere qualche differenza puoi provare a reindirizzare l'output
verso un file, per esempio
test > test.out
magari sostituendo cerr a cout in
cout << t0 << ' ' << t1 << ' ' << t2 << ' '<< t3 << ' '<<t4 << ' ' << t5;
avresti piu` rapidamente delle indicazioni piu` significative.
ciao
Massimo


che significa? me lo puoi spiegare?

"Tjlt!®" ha scritto
: > Nota che io avevo aggiunto prima dell'ultimo ciclo che usa cout una
: > chiamata a
: >
: > cout.sync_with_stdio(false);
: >
: > il cui significato in un loop viene 'annacquato' se non le fai
: > corrispondere una chiamata a
: >
: > cout.sync_with_stdio( true );
: >
: > alla fine del relativo ciclo.
: >
:
: che significa? me lo puoi spiegare?
:
Dall'Help on line del BCB5:
bool
sync_with_stdio(bool sync = true);
When called with a false argument, allows the C++ standard streams
to operate independently of the standard C streams, which greatly
improves performance. When called with a true argument, restores
the default synchronization. The return value of the function is
the status of the synchronization at the time of the call.
Nel mio esempio, volevo valutare questo improvement, se esiste,
chiamandola prima dell'ultimo ciclo in cui misuro le prestazioni di
cout.write.
Se tu fai ripetere la cosa venti volte e per diciannove tutti i cicli
non sono sincronizzati il confronto perde significato.
ciao
Massimo