[C/C++] Wat is sneller?

[cobratbq]

Ik ben een klein proggie aan het maken en dat moet een aantal bestanden snel achter elkaar openen en sluiten. Wat is dan sneller als ik de C-manier gebruik?

FILE* targetfile;
targetfile = fopen( "bestand.ext", "wt" );
fclose( targetfile );

of op de C++ manier?:

ostream targetfile;
targetfile.open( "bestand.ext", ? );
targetfile.close();

(zoiets dan, ik werk nog niet vaak met C++ )

[Verwijderd]

__asm is sneller

nee ik denk dat het niet uitmaakt, alles is best wel geoptimaliseerd.

[justmental]

Probeer het en je weet het.
Lijkt me makkelijker dan voorspellen.

[Sjonny]

het gaat er hier niet om of het progje sneller is, maar de manier waarop je het gaat schrijven. voor jou wordt dat dan C. (schrijf anders beide en maak een benchmark )

[Belgar]

C++ ondersteund ook gewoon fopen hoor. Beide technieken zijn echter zeer verschillend van werking. Bij fopen heb je een 'statisch' object en bij de Stream heb je een eh.. stream (duh). Niet zozeer verschil in werking (snelheid) als wel een verschil in techniek

[edit] kleine verbetering

[curry684]

Reken het eens uit: [topic=230675/1/200]

[D2k]

Op dinsdag 12 maart 2002 16:46 schreef curry684 het volgende:
Reken het eens uit: [topic=230675/1/200]

argh the B word
wat een topic was dat idd
</ot>

[roelio]

als je een aantal bestanden snel moet openen en sluiten lijkt mij de C manier handiger, als je ook echt veel in die bestanden moet lezen/vervangen dan lijkt me de C++ streams beter, maar idd. schrijf een benchmark.

[Verwijderd]

Zou als je op win32 zit een CreateFile niet sneller zijn? iemand al aan het benchen toevallig?

[.oisyn]

Op dinsdag 12 maart 2002 16:58 schreef Yarvieh het volgende:
Zou als je op win32 zit een CreateFile niet sneller zijn? iemand al aan het benchen toevallig?

maken de standaard libs sowieso niet gebruik van CreateFile?

okee, dan is gelijk CreateFile gebruiken waarschijnlijk sneller omdat er geen laagje overheen zit, maar echt superveel zal dat niet schelen denk ik

Op dinsdag 12 maart 2002 16:46 schreef curry684 het volgende:
Reken het eens uit: [topic=230675/1/200]

woei

[PommeFritz]

Tsk

het verkeerde aan het optimaliseren.

Je weet dat vroegtijdig optimaliseren funest is?
Je optimaliseert dan zeer waarschijnlijk al de verkeerde
kant op en ook de verkeerde dingen.

I/O optimaliseren is een van de laatste dingen die ik altijd doe, tenzij *je van te voren weet dat je programma heel zwaar I/O bound is*.

I/O is zo ontzettend veel trager ten opzichte van de rest van je code dat het nagenoeg niets helpt om bij de I/O kleinigheden te optimaliseren.


Conclusie: vergeet het eventuele snelheidsverschil en kies de C++ variant (omdat je toch in C++ werkt).

[Verwijderd]

je lijkt mijn leraar wel, pommefritz....

Meningen verschillen, sommige mensen vinden snelheid en optimalisatie belangrijk, anderen niet. Mijn mening: als je zonder enige extra moeite kan otpimaliseren tijdens design-fase dan moet je dat altijd doen, of het nou 0.1 of 10% snelheidswinst oplevert.

[PommeFritz]

Op dinsdag 12 maart 2002 22:40 schreef beelzebubu het volgende:
[...]als je zonder enige extra moeite kan otpimaliseren tijdens design-fase dan moet je dat altijd doen, of het nou 0.1 of 10% snelheidswinst oplevert.

Deels mee eens.
Compacte efficiente code schrijven is natuurlijk een plus.
Maar de meeste (snelheids)winst is te halen uit het slim uitkienen van de te gebruiken datastructuren (b.v. hash table i.p.v. linked list) of algorithmes (binary search i.p.v. lineaire search).

Pas ook op dat je optimalisatie niet leidt tot ingewikkelde of zelfs onleesbare code (het /* you are not supposed to understand this bad-ass search algoritm */ effect).

[Verwijderd]

ofstream roept de fopen functie zelf op.. dus waarschijnlijk zal het een ietsie pietsie langzamer zijn door de bijkomende overhead, maar ja ik vind ofstream veel mooier.. door de extra operators als << enzo..

btw een ofstream object hoef je niet te closen dat doet de class destructor zelf al wanneer het object out of scope gaat..

btw 2:
een output file stream kan je zo al maken

ofstream targetfile( "bestand.ext", ? );

[Verwijderd]

Op dinsdag 12 maart 2002 12:51 schreef cobratbq het volgende:
Ik ben een klein proggie aan het maken en dat moet een aantal bestanden snel achter elkaar openen en sluiten. Wat is dan sneller als ik de C-manier gebruik?

FILE* targetfile;
targetfile = fopen( "bestand.ext", "wt" );
fclose( targetfile );

of op de C++ manier?:

ostream targetfile;
targetfile.open( "bestand.ext", ? );
targetfile.close();

(zoiets dan, ik werk nog niet vaak met C++ )

Die paar milliseconden merk jij niet.

[cobratbq]

Misschien dat ik wel ff een benchmark maak. Maar het gaat me er in hoofdzaak om dat ik in hoog tempo bestandjes kan openen en sluiten.

Dus een grote for-loop en daarin een file openen en meteen weer sluiten.

Ik ben nog niet zo goed met benchmarks maar ik zal gewoon een begintijd en een eindtijd in een bestandje laten schrijven. Dan weet ik snel genoeg welke nu eigenlijk de snelste is.
Ik weet wel dat je met ruim 500.000 bestanden Win2k al moeite heeft om properties op te vragen

[curry684]

Op woensdag 13 maart 2002 09:47 schreef cobratbq het volgende:
Misschien dat ik wel ff een benchmark maak. Maar het gaat me er in hoofdzaak om dat ik in hoog tempo bestandjes kan openen en sluiten.

Dus een grote for-loop en daarin een file openen en meteen weer sluiten.

Ik ben nog niet zo goed met benchmarks maar ik zal gewoon een begintijd en een eindtijd in een bestandje laten schrijven. Dan weet ik snel genoeg welke nu eigenlijk de snelste is.

Als je nu eens gewoon die link volgt die ik een stuk hierboven gaf vind je kant en klare hopeloos precieze benchmark-code waar je alleen maar de te vergelijken code nog in hoeft te stoppen en hij produceert automatisch de snelheden en het aantal iteraties per test.

Anders doe ik het wel ff voor je:

code:

// ------------------------------------------------------------------------
// IdiotProof Benchmark Code
// Written by Curry, original idea from OiSyN
//
// Benchmarks are accurate no matter what thread priority since time
// elapsed is taken from kernel thread monitoring data
// ------------------------------------------------------------------------

#include <windows.h>
#include <stdio.h>
#include <conio.h>

// ------------------------------------------------------------------------
// Helper macros
// ------------------------------------------------------------------------

// Use this macro at the beginning of the function to declare local
// variables used by the benchmark. 10 million iterations gives a fault
// of max. 1 procent
#define MPrepareBenchmark(p_Iterations)                      \
        LARGE_INTEGER     l_Before, l_After;                  \
        FILETIME        l_CreationTime, l_ExitTime, l_KernelTime;   \
        int        l_Index;                     \
        HANDLE      l_ThreadHandle = GetCurrentThread();      \
        const int      c_Iterations = (p_Iterations)

// The MBeginBenchmark macro initializes loop and prints the method name
#define MBeginBenchmark(p_Name) printf("Method '" #p_Name "'");      \
        GetThreadTimes(l_ThreadHandle, &l_CreationTime, &l_ExitTime,  \
               &l_KernelTime, (LPFILETIME)&l_Before);          \
        for(l_Index = 0; l_Index != c_Iterations; l_Index++) {    

// The MEndBenchmark macro finalizes the loop and prints time results
#define MEndBenchmark }                                \
        GetThreadTimes(l_ThreadHandle, &l_CreationTime, &l_ExitTime,  \
               &l_KernelTime, (LPFILETIME)&l_After);            \
        printf(" took %d milliseconds\n",                    \
             (l_After.QuadPart - l_Before.QuadPart) / 10000)     

// ------------------------------------------------------------------------
// Main program
// ------------------------------------------------------------------------
        
int main()
{
// Define benchmark code
MPrepareBenchmark(10000000);

// Standard C lib version
MBeginBenchmark(StdCLib);
  FILE* targetfile;
  targetfile = fopen( "bestand.ext", "wt" );
  fclose( targetfile );
MEndBenchmark;

// Stream version
MBeginBenchmark(Stream);
  ostream targetfile;
  targetfile.open( "bestand.ext", ? );
  targetfile.close();
MEndBenchmark;

// Wait for keypress before exit
printf("\nPress any key to exit...");
while(!getch());
return 0;
}

// ------------------------------------------------------------------------

Nu alleen nog ff je 2 stukjes subcode finishen en runnen maar.

[.oisyn]

maar we zijn lui en hebben er geen zin in enzo, dus als jij nou ook effe de code erin propt en meet, curry, dan zijn we allemaal weer blij