Benutzen von 'rdbuf()'

[out]

Wäre nett, wenn es jemand auf einem Linux-System nachprüfgen könnte.

[TyRoXx]

#include <iostream>
#include <iterator>
#include <fstream>
#include <algorithm>
#include <vector>
#ifdef _WIN32
#	include <Windows.h>
#else
#	include <sys/time.h>
#	include <unistd.h>
#endif
using namespace std;

namespace
{
#ifndef _WIN32
	typedef long long LONGLONG;
	typedef long long LARGE_INTEGER;

	int QueryPerformanceFrequency(LARGE_INTEGER *f)
	{
		*f = 1000;
		return 1;
	}

	void QueryPerformanceCounter(LARGE_INTEGER *c)
	{
		struct timespec ts = {0};
		clock_gettime(CLOCK_MONOTONIC, &ts);

		*c =
			static_cast<LONGLONG>(ts.tv_sec) * 1000 +
			static_cast<LONGLONG>(ts.tv_nsec) / 1000 / 1000;
	}
#endif

	bool ensureTestFile(const std::string &name, size_t size)
	{
		{
			std::ifstream file(name, std::ios::ate);
			if (file &&
				(file.tellg() == size))
			{
				return true;
			}
		}

		std::ofstream file(name, std::ios::binary);
		static const char content[1UL << 14] = {};
		if (!file)
		{
			return false;
		}

		for (size_t i = 0; i < size; )
		{
			file.write(content,
				std::min<size_t>(sizeof(content), (size - i)));
			i += sizeof(content);
		}

		return true;
	}
}

int main()
{
	static const auto Mebi = (1UL << 20);

	if (!ensureTestFile("test.txt", 100 * Mebi))
	{
		return 1;
	}

	LONGLONG frequency = 0;
	LONGLONG start	 = 0;
	LONGLONG ende	  = 0;
	double elapsed_variante_1 = 0;
	double elapsed_variante_2 = 0;
	double elapsed_variante_3 = 0;
	double elapsed_variante_4 = 0;

	if( !QueryPerformanceFrequency((LARGE_INTEGER*)&frequency) )
		return -1;

	// Variante 2: istream_iterator + copy
	{
		ifstream file("test.txt");
		QueryPerformanceCounter((LARGE_INTEGER*)&start);
		vector<char> v;
		copy( istream_iterator<char>(file>>noskipws), (istream_iterator<char>()), back_inserter(v) );
		QueryPerformanceCounter((LARGE_INTEGER*)&ende);
		elapsed_variante_2 = (((double)(ende-start))/((double)frequency));
	}

	// Variante 1: istream_iterator + constructor
	{
		ifstream file("test.txt");
		QueryPerformanceCounter((LARGE_INTEGER*)&start);
		vector<char> v( istream_iterator<char>(file>>noskipws), (istream_iterator<char>()) );
		QueryPerformanceCounter((LARGE_INTEGER*)&ende);
		elapsed_variante_1 = (((double)(ende-start))/((double)frequency));
	}

	// Variante 4: istreambuf_iterator + copy
	{
		ifstream file("test.txt");
		QueryPerformanceCounter((LARGE_INTEGER*)&start);
		vector<char> v;
		copy( istreambuf_iterator<char>(file), (istreambuf_iterator<char>()), back_inserter(v) );
		QueryPerformanceCounter((LARGE_INTEGER*)&ende);
		elapsed_variante_4 = (((double)(ende-start))/((double)frequency));
	}

	// Variante 3: istreambuf_iterator + constructor
	{
		ifstream file("test.txt");
		QueryPerformanceCounter((LARGE_INTEGER*)&start);
		vector<char> v( istreambuf_iterator<char>(file), (istreambuf_iterator<char>()) );
		QueryPerformanceCounter((LARGE_INTEGER*)&ende);
		elapsed_variante_3 = (((double)(ende-start))/((double)frequency));
	}

	cout << "elapsed_variante_1 = " << elapsed_variante_1 << endl;
	cout << "elapsed_variante_2 = " << elapsed_variante_2 << endl;
	cout << "elapsed_variante_3 = " << elapsed_variante_3 << endl;
	cout << "elapsed_variante_4 = " << elapsed_variante_4 << endl;
}

$ /usr/lib/gcc-snapshot/bin/g++ --version
g++ (Ubuntu/Linaro 20120314-0ubuntu2) 4.8.0 20120314 (experimental) [trunk revision 185382]
[...]
$ /usr/lib/gcc-snapshot/bin/g++ main.cpp -omain -std=c++0x -lrt -O3
$ ./main 
elapsed_variante_1 = 3.372
elapsed_variante_2 = 3.446
elapsed_variante_3 = 0.922
elapsed_variante_4 = 0.905

[out]

Danke TyRoXx. Unterm Strich kommt es also praktisch auf dasselbe heraus. Trotzdem interessant, finde ich. Hätte eher gedacht, dass std::vector -Konstruktor ein bisschen deutlicher vorne liegen würde.

[Wutz]

out schrieb:

if( !QueryPerformanceFrequency((LARGE_INTEGER*)&frequency) )

Was soll dieser Müll-Cast denn hier?
Willst damit wohl eine Compilerwarnung zudecken, was glaubst du wohl, warum der Compiler die Warnung ausgibt?
Richtig! Weil der Compiler Ahnung hat im Gegensatz zu dir. Zeigercasts sind prinzipiell schlecht und deuten allermeistens auf fehlerhaftes Programmdesign hin.

[Swordfish]

out schrieb:

Meine Gegebenheiten:
`

i7-860 2.80GHz (8 CPUs)

8 GB RAM

Windows 7 Prof. 64-Bit

Visual Studio 2008 Prof.

Optimierung: /O2

`

Messergebnisse:
`

Variante 1: istream_iterator + ostream_iterator = 17,78 Sekunden

Variante 2: istream_iterator + ostreambuf_iterator = 8,97 Sekunden

Variante 3: istreambuf_iterator + ostream_iterator = 10,45 Sekunden

Variante 4: istreambuf_iterator + ostreambuf_iterator = 2,58 Sekunden

Variante 5: einfach rdbuf = 2,53 Sekunden

Variante 6: read + write (8192 Byte Blöcke) = 0,83 Sekunden

`

Lahme Krücke
`elapsed_variante_1 = 10.3109

elapsed_variante_2 = 4.85142

elapsed_variante_3 = 6.86091

elapsed_variante_4 = 1.5387

elapsed_variante_5 = 1.3171

elapsed_variante_6 = 0.427581`

[tntnet]

Swordfish schrieb:

out schrieb:

Meine Gegebenheiten:
`

i7-860 2.80GHz (8 CPUs)

8 GB RAM

Windows 7 Prof. 64-Bit

Visual Studio 2008 Prof.

Optimierung: /O2

`

Messergebnisse:
`

Variante 1: istream_iterator + ostream_iterator = 17,78 Sekunden

Variante 2: istream_iterator + ostreambuf_iterator = 8,97 Sekunden

Variante 3: istreambuf_iterator + ostream_iterator = 10,45 Sekunden

Variante 4: istreambuf_iterator + ostreambuf_iterator = 2,58 Sekunden

Variante 5: einfach rdbuf = 2,53 Sekunden

Variante 6: read + write (8192 Byte Blöcke) = 0,83 Sekunden

`

Lahme Krücke
`elapsed_variante_1 = 10.3109

elapsed_variante_2 = 4.85142

elapsed_variante_3 = 6.86091

elapsed_variante_4 = 1.5387

elapsed_variante_5 = 1.3171

elapsed_variante_6 = 0.427581`

Hier sind meine Ergebnisse:
elapsed_variante_1 = 4.313
elapsed_variante_2 = 1.719
elapsed_variante_3 = 3.135
elapsed_variante_4 = 0.092
elapsed_variante_5 = 0.091
elapsed_variante_6 = 0.083
Warum ist bei mir die schnellste Variante um den Faktor 5 schneller, als Deine schnellste?

Übrigens: Intel i5, Fedora 17, x64_64 auf Intel i5.
Ist Linux an der Stelle jetzt so viel schneller?

[Ethon]

Du musst das relativ sehen. Caching, Festplattengeschwindigkeit etc machen einen großen Unterschied.

[Oberon_0]

Was passiert wenn man Variante 6 als erstes testet? Caching könnte die Ergebnisse verfälschen.

[Ethon]

Jep. Eigentlich müsste mn ja mit nem strinngstream testen.

[tntnet]

Ethon schrieb:

Du musst das relativ sehen. Caching, Festplattengeschwindigkeit etc machen einen großen Unterschied.

Caching von was? Hat meine Festplatte ein besseres Caching oder Linux? Genau das ist ja die Frage.

Ich verweise ja auf den Beitrag von Swordfish, der meint, sein System sei keine lahme Krücke. Da frage ich mich halt, ob meine Festplatte so gigantisch gut ist oder mein Betriebssystem.

Und noch zu der Frage von Oberon_O: Hier sind die Ergebnisse, wenn ich Test 6 an den Anfang verschiebe:
elapsed_variante_1 = 4.045
elapsed_variante_2 = 1.559
elapsed_variante_3 = 2.699
elapsed_variante_4 = 0.091
elapsed_variante_5 = 0.09
elapsed_variante_6 = 0.081

Also nein - es macht nichts aus.

[Ethon]

Caching von was? Hat meine Festplatte ein besseres Caching oder Linux? Genau das ist ja die Frage.

Afaik cacht Liux beträchtlich mehr. Bei Linux beschwert sich ja niemand wenn das OS nach dem Start mal eben 4GB RAM verwendet.

[tntnet]

Ethon schrieb:

Jep. Eigentlich müsste mn ja mit nem strinngstream testen.

Hier meine Ergebnisse mit ostringstream:

elapsed_variante_1 = 3.498
elapsed_variante_2 = 1.545
elapsed_variante_3 = 2.407
elapsed_variante_4 = 0.077
elapsed_variante_5 = 0.077
elapsed_variante_6 = 0.075

[stirni]

Ethon schrieb:

Jep. Eigentlich müsste mn ja mit nem strinngstream testen.

Eigentlich nicht. Es geht ja um das blockweise kopieren.

[Ethon]

stirni schrieb:

Ethon schrieb:

Jep. Eigentlich müsste mn ja mit nem strinngstream testen.

Eigentlich nicht. Es geht ja um das blockweise kopieren.

Höh? Es geht doch um die Performance der verschiedenen Methoden um Daten von Stream a nach Stream b zu kopieren.

[tntnet]

Ethon schrieb:

stirni schrieb:

Ethon schrieb:

Jep. Eigentlich müsste mn ja mit nem strinngstream testen.

Eigentlich nicht. Es geht ja um das blockweise kopieren.

Höh? Es geht doch um die Performance der verschiedenen Methoden um Daten von Stream a nach Stream b zu kopieren.

Ach ich habe eher das Gefühl, wir probieren mal dies und mal das. Und ich finde das sehr spannend .

Wenn es nur um das kopieren eines Streams in einen anderen ginge, sollten wir eher mal einfach von einem std::istringstream in einen std::ostringstream kopieren. Sollten wir das mal ausprobieren?

[out]

tntnet schrieb:

Wenn es nur um das kopieren eines Streams in einen anderen ginge, sollten wir eher mal einfach von einem std::istringstream in einen std::ostringstream kopieren. Sollten wir das mal ausprobieren?

Klar wieso nicht. Ich werde es dann auch noch auf meinem Heimrechner testen.

[Swordfish]

tntnet schrieb:

Ich verweise ja auf den Beitrag von Swordfish, der meint, sein System sei keine lahme Krücke. [...]

Ist es auch nicht. Bei den Platten handelt es sich um 3 Seagate Constellation an einem Areca 6 GB/s SAS Raid Controller im RAID 5. Ich fürchte eher, daß der QPI-Link mit nur ~3,3 GHz (zwecks OC'ing) der Flaschenhals ist. Ich teste später nochmal mit QPI @ 6,4 GHz.

[beneider]

Alter. Hör mal auf mit deinem System anzugeben.

[Sone]

beneider schrieb:

Alter. Hör mal auf mit deinem System anzugeben.

Wieso sollte man darauf neidisch sein? Edit: Neh, Spaß beiseite. Das ist schon geil.

[tntnet]

Ich habe jetzt mal mit stringstream getestet. Hier sind die Ergebnisse:
elapsed_variante_1 = 3.51375
elapsed_variante_2 = 1.53196
elapsed_variante_3 = 2.4565
elapsed_variante_4 = 0.0676401
elapsed_variante_5 = 0.0679622
elapsed_variante_6 = 0.0699324

Was wir hier sehen ist, dass der ostream_iterator langsamer ist, als der istream_iterator. Das ist auch mal eine interessante Erkenntnis.

Ich habe übrigens das Testprogramm ein wenig überarbeitet. Diese grauenvollen Pointer-casts habe ich ersetzt. Und Systemspezifische Sachen gehören abstrahiert. Statt Windows Interfaces für Linux zu implementieren habe ich ein einheitliches Interface für beide gemacht.

Ich habe das nur auf Linux getestet, da ich kein Windows habe. Dennoch habe ich versucht, die WIN32-Version auch zu implementieren. Könnt ihr mal testen?

Hier ist mein Code:

#include <iostream>
#include <iterator>
#include <sstream>
#include <algorithm>
#include <time.h>
#ifdef _WIN32
#    include <Windows.h>
#else
#    include <sys/time.h>
#    include <unistd.h>
#endif

#ifdef _WIN32
class Clock
{
    static LARGE_INTEGER _frequency;
    LARGE_INTEGER _start;

  public:
    Clock();
    void reset();
    double elapsed() const;
};

LARGE_INTEGER Clock::_frequency = 0;

Clock::Clock()
{
    if (_frequency == 0)
        QueryPerformanceFrequency(&_frequency);
    reset();
}

void Clock::reset()
{
    QueryPerformanceCounter(_start);
}

double Clock::elapsed() const
{
    LARGE_INTEGER end;
    QueryPerformanceCounter(end);
    return static_cast<double>(end - _start) / _frequency;
}

#else

class Clock
{
    struct timespec _start;

  public:
    Clock();
    void reset();
    double elapsed() const;
};

Clock::Clock()
{
    reset();
}

void Clock::reset()
{
    clock_gettime(CLOCK_MONOTONIC, &_start);
}

double Clock::elapsed() const
{
    struct timespec end;
    clock_gettime(CLOCK_MONOTONIC, &end);
    return (end.tv_sec - _start.tv_sec - 1) + (1000000000 + end.tv_nsec - _start.tv_nsec) / 1e9;
}

#endif

int main(int argc, char* argv[])
{
    std::istringstream inp(std::string(104857600, ' '));

    // Variante 1: std::istream_iterator + std::ostream_iterator
    {
        std::ostringstream out;
        inp.clear();
        inp.seekg(0);

        Clock clock;

        std::copy( std::istream_iterator<char>(inp>>std::noskipws), (std::istream_iterator<char>()), std::ostream_iterator<char>(out) );

        double elapsed = clock.elapsed();
        std::cout << "elapsed_variante_1 = " << elapsed << std::endl;
    }

    // Variante 2: std::istream_iterator + std::ostreambuf_iterator
    {
        std::ostringstream out;
        inp.clear();
        inp.seekg(0);

        Clock clock;

        std::copy( std::istream_iterator<char>(inp>>std::noskipws), (std::istream_iterator<char>()), std::ostreambuf_iterator<char>(out) );

        double elapsed = clock.elapsed();
        std::cout << "elapsed_variante_2 = " << elapsed << std::endl;
    }

    // Variante 3: std::istreambuf_iterator + std::ostream_iterator
    {
        std::ostringstream out;
        inp.clear();
        inp.seekg(0);

        Clock clock;

        std::copy( std::istreambuf_iterator<char>(inp), std::istreambuf_iterator<char>(), std::ostream_iterator<char>(out) );

        double elapsed = clock.elapsed();
        std::cout << "elapsed_variante_3 = " << elapsed << std::endl;
    }

    // Variante 4: std::istreambuf_iterator + std::ostreambuf_iterator
    {
        std::ostringstream out;
        inp.clear();
        inp.seekg(0);

        Clock clock;

        std::copy( std::istreambuf_iterator<char>(inp), std::istreambuf_iterator<char>(), std::ostreambuf_iterator<char>(out) );

        double elapsed = clock.elapsed();
        std::cout << "elapsed_variante_4 = " << elapsed << std::endl;
    }

    // Variante 5: einfach rdbuf
    {
        std::ostringstream out;
        inp.clear();
        inp.seekg(0);

        Clock clock;

        out << inp.rdbuf();

        double elapsed = clock.elapsed();
        std::cout << "elapsed_variante_5 = " << elapsed << std::endl;
    }

    // Variante 6: read + write (8192 Byte Blöcke)
    {
        std::ostringstream out;
        inp.clear();
        inp.seekg(0);

        Clock clock;

        char buffer[8192];
        while( inp.read(buffer, sizeof(buffer)) && inp.gcount()>0 )
        {
            out.write(buffer, inp.gcount());
        }

        double elapsed = clock.elapsed();
        std::cout << "elapsed_variante_6 = " << elapsed << std::endl;
    }

}