Java vs. C#

[thomas80d]

Ich hab mal die C++-Version abgeändert auf stringstreams. Ist jetzt bedeutend schneller.

#include <iostream>
#include <cmath>
#include <limits>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <functional>
using namespace std;
#include <windows.h>

#ifdef _MSC_VER 
#undef max
#endif

int main()
{
  DWORD times[7];  
  const size_t arrayLength=5000000;  
  size_t i=0;

  //Arrays erzeugen  
  times[0] = GetTickCount();
  int *intArray=new int[arrayLength];
  double *doubleArray=new double[arrayLength];
  times[1] = GetTickCount();

  //Zufallszahlen
  srand(unsigned int(0));
  for(;i<arrayLength;++i)
  {
    intArray[i]=static_cast<int>(numeric_limits<int>::max()*rand()/RAND_MAX+1.0);
    doubleArray[i]=(numeric_limits<double>::max()*rand()/RAND_MAX+1.0);
  }
  times[2] = GetTickCount();

  //Sortieren
  sort(&intArray[0], &intArray[arrayLength-1], less<int>());  
  times[3] = GetTickCount();

  //int to char
  ostringstream stringBuffer();  
  for(i=0;i<arrayLength;++i)
  {
    stringBuffer << intArray[i] << endl;    
  }
  times[4] = GetTickCount();

  //string in Datei schreiben
  ofstream out("demo.txt");
  if(!out.is_open())
  {
    cerr << "Fehler" << endl;
    return 1;
  }
  out << stringBuffer.str();
  out.close();
  times[5] = GetTickCount();

  //Wurzeln berechnen
  for(i=0;i<arrayLength;++i)
    doubleArray[i]=sqrt(doubleArray[i]);
  times[6] = GetTickCount();

  //Ausgabe:
  cout << "Array erzeugen: " << times[1] - times[0] << "ms" << endl;
  cout << "Zufallszahlen erzeugen: " << times[2] - times[1] << "ms" << endl;
  cout << "Sortieren: " << times[3] - times[2] << "ms" << endl;
  cout << "String anhängen: " << times[4] - times[3] << "ms" << endl;
  cout << "Speichern: " <<  times[5] - times[4] << "ms" << endl;
  cout << "Wurzeln berechnen: " <<  times[6] - times[5] << "ms" << endl;

  delete[] intArray;
  delete[] doubleArray;  

}

[ Dieser Beitrag wurde am 10.10.2002 um 08:52 Uhr von thomas80d editiert. ]

[Gregor]

Mein Compiler meckert mal wieder überall dran rum.

Benchmark.cpp:28: parse error before 'int'
Benchmark.cpp:41: invalid conversion from 'unsigned int' to 'std::_Ios_Openmode'
Benchmark.cpp:41: initializing argument 1 of 'std::basic_ostringstream<_CharT, _Traits, _Alloc>::basic_ostringstream(std::_Ios_Openmode) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]'

...ich weiß natürlich nicht, was diese Fehler bedeuten.

[ Dieser Beitrag wurde am 09.10.2002 um 23:41 Uhr von Gregor editiert. ]

[rüdiger]

ich war gestern leider krank, will aber noch meine Version mit vectoren posten, da man dann auch sort verwenden kann.

[Gregor]

Immer her mit anderen Versionen. Bin mal gespannt, wann jemand eine bringt, die mein Compiler tatsächlich akzeptiert.

BTW : @Thomas : Nach der Veränderung sind die beiden Fehler in Zeile 41 weg. Dafür sind zwei neue Fehler in den Zeilen 44 und 55 entstanden. ...wenn das bei dir kompiliert, dann kannst du mir ja einfach wieder eine ausführbare Datei schicken!

[CengizS]

... wie schön dass man C++-Programme schreiben kann die dann auf allen(! *rofl*) Maschinen und Compilern lauffähig bzw. Kompilierbar sind ...

SCNR

[Descartes]

probierts mal folgendes:

#include <iostream>     /* std::cout std::endl */
#include <cmath>        /* sqrt() */
#include <ctime>        /* time_t difftime() */
#include <fstream>      /* std::ofstream */
#include <algorithm>
#include <functional>
#include <limits>
#include <sstream>      /* std::ostringstream */

// using namespace std;

#ifdef WIN32
  #include <windows.h>
  #ifdef _MSC_VER 
    #undef max
  #endif
#else
  #include <sys/time.h>
#endif

int main()
{
#ifdef WIN32
  DWORD times[7];  
#else
  struct timeval times[7];
  struct timezone tz;
#endif
  const size_t arrayLength=5000000;  
  size_t i=0;

  //Arrays erzeugen  
#ifdef WIN32
  times[0] = GetTickCount();
#else
  gettimeofday(×[0], &tz);
#endif
  int *intArray=new int[arrayLength];
  double *doubleArray=new double[arrayLength];
#ifdef WIN32
  times[1] = GetTickCount();
#else
  gettimeofday(×[1], &tz);
#endif

  //Zufallszahlen
  srand( (unsigned int)0 );
  for(;i<arrayLength;++i)
    {
      intArray[i]    = static_cast<int>(std::numeric_limits<int>::max() * rand() / RAND_MAX + 1.0);
      doubleArray[i] = (std::numeric_limits<double>::max() * rand() / RAND_MAX + 1.0);
    }
#ifdef WIN32
  times[2] = GetTickCount();
#else
  gettimeofday(×[2], &tz);
#endif

  //Sortieren
  sort(&intArray[0], &intArray[arrayLength-1], std::less<int>());
#ifdef WIN32
  times[3] = GetTickCount();
#else
  gettimeofday(×[3], &tz);
#endif

  //int to char
  std::ostringstream stringBuffer;  
  for(i=0;i<arrayLength;++i)
    {
      stringBuffer << intArray[i] << std::endl;
    }
#ifdef WIN32
  times[4] = GetTickCount();
#else
  gettimeofday(×[4], &tz);
#endif

  //string in Datei schreiben
  std::ofstream out("demo.txt");
  if(!out.is_open())
     {
      std::cerr << "Fehler" << std::endl;
      delete[] intArray;
      delete[] doubleArray;  
      return 1;
    }
  out << stringBuffer.str();
  out.close();
#ifdef WIN32
  times[5] = GetTickCount();
#else
  gettimeofday(×[5], &tz);
#endif

  //Wurzeln berechnen
  for(i=0; i<arrayLength; ++i)
    {
      doubleArray[i] = sqrt(doubleArray[i]);
    }
//  for_each(doubleArray[0], doubleArray[arrayLength - 1], sqrt);

#ifdef WIN32
  times[6] = GetTickCount();
#else
  gettimeofday(×[6], &tz);
#endif

  //Ausgabe:
#ifdef WIN32
  std::cout << "Array erzeugen: " 
            << (times[1] - times[0])
            << std::endl;
  std::cout << "Zufallszahlen erzeugen: "
            << (times[2] - times[1])
            << std::endl;
  std::cout << "Sortieren: "
            << (times[3] - times[2])
            << std::endl;
  std::cout << "String anhaengen: "
            << (times[4] - times[3])
            << std::endl;
  std::cout << "Speichern: "
            << (times[5] - times[4])
            << std::endl;
  std::cout << "Wurzeln berechnen: "
            << (times[6] - times[5])
            << std::endl;
#else
  std::cout << "Array erzeugen: " 
            << (times[1].tv_usec - times[0].tv_usec)
            << std::endl;
  std::cout << "Zufallszahlen erzeugen: "
            << (times[2].tv_usec - times[1].tv_usec)
            << std::endl;
  std::cout << "Sortieren: "
            << (times[3].tv_usec - times[2].tv_usec)
            << std::endl;
  std::cout << "String anhaengen: "
            << (times[4].tv_usec - times[3].tv_usec)
            << std::endl;
  std::cout << "Speichern: "
            << (times[5].tv_usec - times[4].tv_usec)
            << std::endl;
  std::cout << "Wurzeln berechnen: "
            << (times[6].tv_usec - times[5].tv_usec)
            << std::endl;
#endif

  delete[] intArray;
  delete[] doubleArray;  

  return 0;
}

[Gregor]

Gratuliere! Der Code kompiliert bei mir. Es sollte aber noch schneller gehen. ...das Sort von der letzten Version ist z.B. deutlich schneller. Hier die Ergebnisse :

1,2 GHz         1,6 GHz
Array                :          0               0
Zufallszahlen        :       1241             921
sortieren            :       2654            2003
String erzeugen      :     107054           79053
Speichern            :      10495            4327
Wurzel berechnen     :        912             631

Ich habe meinen PC aber nicht dafür neu gestartet. Kann also sein, dass man durchaus noch etwas bessere Ergebnisse erreichen könnte. ...könnte auch sein, dass bessere Ergebnisse rauskommen, wenn mir noch jemand verrät, wie man g++ dazu bringen kann, besser zu optimieren. (falls man das kann)

[Gregor]

BTW : Die erzeugte Textdatei ist interessant. Sie ist nur 24MB groß und es sind nur die Zahlen 1, 65538 und 65539 enthalten. Die letzte Zahl ist eine 65538. Es stellen sich also folgende Fragen :

1. Warum wird nicht richtig sortiert?
2. Warum werden nur diese 3 Zahlen erzeugt?

[ Dieser Beitrag wurde am 11.10.2002 um 02:28 Uhr von Gregor editiert. ]

[Gregor]

nochmal BTW : Ich habe gerade gesehen, dass das Programm mit diesen "x" kompiliert wurde. Interessant, dass das geht!

[ Dieser Beitrag wurde am 11.10.2002 um 03:47 Uhr von Gregor editiert. ]

[thomas80d]

Original erstellt von Gregor:
**nochmal BTW : Ich habe gerade gesehen, dass das Programm mit diesen "x" kompiliert wurde. Interessant, dass das geht!

[ Dieser Beitrag wurde am 11.10.2002 um 03:47 Uhr von [qb]Gregor** editiert. ][/QB]

Na, das ist so nicht ganz richtig. Da du ja Windows verwendet und der Code mit dem "x" in dem Nicht-Windows Teil steht, wird das gar nicht mitkompiliert.

[rüdiger]

Versuch mal beim g++ folgende Optionen

g++ -O3 -Wall -W -fomit-frame-pointer -fschedule-insns2 -malign-double -pipe -march=athlon -mcpu=athlon -o code code.cc

athlon musst du durch den CPU Typ ersetzen, den du benutzt. Es kann sein, dass die Optionen -fschedule-insns2 -malign-double Probleme bereiten.

So ich schreib mal den Code mit den vectoren auf Descartes Code um

BTW.
Das mit dem x aus × muss ich mal Loggy melden

[rüdiger]

#include <iostream>     /* std::cout std::endl */
#include <cmath>        /* sqrt() */
#include <ctime>        /* time_t difftime() */
#include <fstream>      /* std::ofstream */
#include <algorithm>
#include <functional>
#include <limits>
#include <sstream>      /* std::ostringstream */
#ifndef NO_VECTOR
#include <vector>
#endif

// using namespace std;

#ifdef WIN32
  #include <windows.h>
  #ifdef _MSC_VER 
    #undef max
  #endif
#else
  #include <sys/time.h>
#endif

int main()
{
#ifdef WIN32
  DWORD times[7];  
#else
  struct timeval times[7];
  struct timezone tz;
#endif
  const size_t arrayLength=5000000;  
  size_t i=0;

  //Arrays erzeugen  
#ifdef WIN32
  times[0] = GetTickCount();
#else
  gettimeofday(×[0], &tz);
#endif
#ifdef NO_VECTOR
  int *intArray=new int[arrayLength];
  double *doubleArray=new double[arrayLength];
#else
  std::vector<int> intArray(arrayLength);
  std::vector<double> doubleArray(arrayLength);
#endif
#ifdef WIN32
  times[1] = GetTickCount();
#else
  gettimeofday(×[1], &tz);
#endif

  //Zufallszahlen
  std::srand( (unsigned int)0 );
  for(;i<arrayLength;++i)
    {
      #ifdef NO_VECTOR
      intArray[i]    = static_cast<int>(std::numeric_limits<int>::max() * rand() / RAND_MAX + 1.0);
      doubleArray[i] = (std::numeric_limits<double>::max() * rand() / RAND_MAX + 1.0);
      #else
      intArray.push_back(static_cast<int>(std::numeric_limits<int>::max() * std::rand() / RAND_MAX + 1.0));
      doubleArray.push_back(std::numeric_limits<double>::max() * std::rand() / RAND_MAX + 1.0);
      #endif
    }
#ifdef WIN32
  times[2] = GetTickCount();
#else
  gettimeofday(×[2], &tz);
#endif

  //Sortieren
  #ifdef NO_VECTOR
  sort(&intArray[0], &intArray[arrayLength-1], std::less<int>());
  #else
  sort(intArray.begin(), intArray.end(), std::less<int>());
  #endif
#ifdef WIN32
  times[3] = GetTickCount();
#else
  gettimeofday(×[3], &tz);
#endif

  //int to char
  std::ostringstream stringBuffer;  
  for(i=0;i<arrayLength;++i)
    {
      stringBuffer << intArray[i] << std::endl;
    }
#ifdef WIN32
  times[4] = GetTickCount();
#else
  gettimeofday(×[4], &tz);
#endif

  //string in Datei schreiben
  std::ofstream out("demo.txt");
  if(!out.is_open())
     {
      std::cerr << "Fehler" << std::endl;
      #ifdef NO_VECTOR
      delete[] intArray;
      delete[] doubleArray;
      #endif
      return 1;
    }
  out << stringBuffer.str();
  out.close();
#ifdef WIN32
  times[5] = GetTickCount();
#else
  gettimeofday(×[5], &tz);
#endif

  //Wurzeln berechnen
  for(i=0; i<arrayLength; ++i)
    {
      doubleArray.push_back(std::sqrt(doubleArray[i]));
    }
//  for_each(doubleArray[0], doubleArray[arrayLength - 1], sqrt);

#ifdef WIN32
  times[6] = GetTickCount();
#else
  gettimeofday(×[6], &tz);
#endif

  //Ausgabe:
#ifdef WIN32
  std::cout << "Array erzeugen: " 
            << (times[1] - times[0])
            << std::endl;
  std::cout << "Zufallszahlen erzeugen: "
            << (times[2] - times[1])
            << std::endl;
  std::cout << "Sortieren: "
            << (times[3] - times[2])
            << std::endl;
  std::cout << "String anhaengen: "
            << (times[4] - times[3])
            << std::endl;
  std::cout << "Speichern: "
            << (times[5] - times[4])
            << std::endl;
  std::cout << "Wurzeln berechnen: "
            << (times[6] - times[5])
            << std::endl;
#else
  std::cout << "Array erzeugen: " 
            << (times[1].tv_usec - times[0].tv_usec)
            << std::endl;
  std::cout << "Zufallszahlen erzeugen: "
            << (times[2].tv_usec - times[1].tv_usec)
            << std::endl;
  std::cout << "Sortieren: "
            << (times[3].tv_usec - times[2].tv_usec)
            << std::endl;
  std::cout << "String anhaengen: "
            << (times[4].tv_usec - times[3].tv_usec)
            << std::endl;
  std::cout << "Speichern: "
            << (times[5].tv_usec - times[4].tv_usec)
            << std::endl;
  std::cout << "Wurzeln berechnen: "
            << (times[6].tv_usec - times[5].tv_usec)
            << std::endl;
#endif

#ifdef NO_VECTOR
  delete[] intArray;
  delete[] doubleArray;
#endif

  return 0;
}

[Gregor]

<Descartes> Code mit den genannten Compiler-Optionen :

1,2 GHz         1,6 GHz
Array                :          0               0
Zufallszahlen        :       1132             842
sortieren            :        470             400
String erzeugen      :     105052           78092
Speichern            :      10254            4316
Wurzel berechnen     :        221             160

Sieht schon deutlich besser aus.

[Gregor]

Kingruedis Code mit den genannten Compiler-Optionen :

1,2 GHz         1,6 GHz
Array                :        130             120
Zufallszahlen        :       1502            1162
sortieren            :       1412            1101
String erzeugen      :     103999           76490
Speichern            :       5158            3165
Wurzel berechnen     :        561             460

...bei mir schwanken die Ergebnisse übrigens von mal zu mal recht stark. Wenn mir etwas komisch vorkommt, dann mache ich die Messung immer nochmal. Hier war z.B. das "Wurzel berechnen" bei einer Mesung sehr langsam (4026).

Ich zeige gleich mal meine Java-Version, bei der ich die Stringerzeugung per Hand mache. Vielleicht hilft die Version, das in C++ effizienter zu implementieren.

EDIT : Die txt-Datei hat hier übrigens nur 15MB!

[ Dieser Beitrag wurde am 11.10.2002 um 14:00 Uhr von Gregor editiert. ]

[Gregor]

2. Java-Variante (per Hand String + Sortieren)

1,2 GHz         1,6 GHz
Array                :        190             181
Zufallszahlen        :       4677            3495
sortieren            :       2683            2013
String erzeugen      :       2784            2093
Speichern            :       2844            2844
Wurzel berechnen     :        181             130

Komischerweise wirken sich die MHz hier garnicht auf die Geschwindigkeit des Speicherns aus.

der Code :
[java]
import java.util.;
import java.io.;

public class Benchmark2
{
public Benchmark2 ()
{
}

private final static byte [] digits = {'0','1','2','3','4','5','6','7','8','9'};

private final static byte [] DigitTens = {
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
} ;

private final static byte [] DigitOnes = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
} ;

public static void main (String[] args)
{
long [] times = new long [7];
int i;
int arrayLength = 5000000;
times [0] = System.currentTimeMillis ();
// Array erzeugen
int [] array = new int [arrayLength];
double [] doubleArray = new double [arrayLength];
times [1] = System.currentTimeMillis ();
// Zufallszahlen erzeugen
Random rand = new Random();
for (i = 0 ; i < arrayLength ; ++i)
{
array[i] = rand.nextInt ();
doubleArray[i] = rand.nextDouble ();
}
times [2] = System.currentTimeMillis ();
// Array sortieren
sort (array);
times [3] = System.currentTimeMillis ();
// Zahlen des Arrays in einen großen String verwandeln (jede Zeile eine Zahl)
byte [] byteArray = new byte [arrayLength * 12];
int pos = 0;
int currentStringPos;
byte [] tempString;
for (i = 0 ; i < array.length ; ++i)
{
pos = addIntegerToString (array[i], byteArray, pos);
byteArray [pos] = '\n';
++pos;
}
times [4] = System.currentTimeMillis ();
// String in eine Datei abspeichern
BufferedOutputStream stream;
try
{
stream = new BufferedOutputStream (new FileOutputStream ("test.txt"));
stream.write (byteArray,0,pos);
stream.close ();
}
catch (IOException e)
{
System.out.println ("FEHLER FEHLER FEHLER FEHLER FEHLER");
}
times [5] = System.currentTimeMillis ();
// Wurzeln berechnen
for (i = 0 ; i < doubleArray.length ; ++i)
{
doubleArray[i] = Math.sqrt(doubleArray[i]);
}
times [6] = System.currentTimeMillis ();
// Ausgabe der Zeiten
System.out.println ("Array erzeugen : " + String.valueOf (times[1]-times[0]) + "ms");
System.out.println ("Zufallszahlen erzeugen : " + String.valueOf (times[2]-times[1]) + "ms");
System.out.println ("Sortieren : " + String.valueOf (times[3]-times[2]) + "ms");
System.out.println ("String (anhängen) : " + String.valueOf (times[4]-times[3]) + "ms");
System.out.println ("Speichern : " + String.valueOf (times[5]-times[4]) + "ms");
System.out.println ("Wurzeln berechnen : " + String.valueOf (times[6]-times[5]) + "ms");
}

private final static int addIntegerToString(int i, byte [] string, int currentPos)
{
int q, r, charPos ;
charPos = 12 ;
byte buf [] = new byte [charPos] ;
byte sign = 0 ;

if (i == Integer.MIN_VALUE)
{
buf = new byte [] {'0','-','2','1','4','7','4','8','3','6','4','8'};
charPos = 1;
}
else
{
if (i < 0)
{
sign = '-' ;
i = -i ;
}

// Generate two digits per iteration
while ( i >= 65536 )
{
q = i / 100 ;
// really: r = i - (q * 100) ;
r = i - ((q << 6) + (q << 5) + (q << 2)) ;
i = q ;
buf [--charPos] = DigitOnes [r] ;
buf [--charPos] = DigitTens [r] ;
}

// Fall thru to fast mode for smaller numbers
// assert(i <= 65536, i);
for (;;)
{
q = (i * 52429) >>> (16+3) ;
r = i - ((q << 3) + (q << 1)) ; // r = i-(q*10) ...
buf [--charPos] = digits [r] ;
i = q ;
if (i == 0) break ;
}
if (sign != 0)
{
buf [--charPos] = sign ;
}
}

int end = 12 - charPos+currentPos;
for (;currentPos < end ; ++currentPos, ++charPos)
{
string [currentPos] = buf[charPos];
}
return currentPos;
}

private final static void sort (int [] a)
{
quickSort (a,0,a.length-1);
}

private final static void quickSort (int [] a, int begin, int end)
{
int i=begin,j=end;
int pivotElement = a[((end + begin) >>> 1)];
int temp = 0;
while (i < j)
{
while (a[i] < pivotElement) ++i;
while (a[j] > pivotElement) --j;
if (a[i] == (temp = a[j]))
{
++i;
continue;
}
a[j] = a[i];
a[i] = temp;
if (a[i] != pivotElement) ++i;
else
{
temp = ((j-i) >>> 1) + i;
a[i] = a[temp];
a[temp] = pivotElement;
}
if (a[j] != pivotElement) --j;
else
{
temp = ((j-i) >>> 1) + i;
a[j] = a[temp];
a[temp] = pivotElement;
}
}
if ((temp = j - begin) > 18) quickSort (a,begin,j-1);
else if (temp > 1) insertionSort (a,begin,j-1);
if ((temp = end - j) > 18) quickSort (a,j+1,end);
else if (temp > 1) insertionSort (a,j+1,end);
}

private final static void insertionSort (int [] a, int begin, int end)
{
int j, b;
int temp;
int i = begin;
while (i != end)
{
++i;
temp = a[i];
b = i;
j = i - 1;
while (temp < a[j])
{
a[b] = a[j];
b = j;
--j;
if (b == begin) break;
}
a[b] = temp;
}
}
}[/code]

[Helium]

#ifdef NO_VECTOR
      intArray[i]    = static_cast<int>(std::numeric_limits<int>::max() * rand() / RAND_MAX + 1.0);
      doubleArray[i] = (std::numeric_limits<double>::max() * rand() / RAND_MAX + 1.0);
      #else
      intArray.push_back(static_cast<int>(std::numeric_limits<int>::max() * std::rand() / RAND_MAX + 1.0));
      doubleArray.push_back(std::numeric_limits<double>::max() * std::rand() / RAND_MAX + 1.0);
      #endif

Stand irgendwo lege ein Feld der Große arrayLength und hänge hinten ein paar Zufalszahlen an? oder was soll das push_back???

Und ich habe grade einfach mahl versucht das ganze auf dem MSVC laufenzulassen. Ging natürlich nicht, weil bei dem nur etwa die hälfte im richtigen Namensraum steht. Und der hat extrem langsame stringstreams. Deshalb habe ich das ganze mal an den MSVC angepast und dann folgende Ergebnisse bekommen

211
434
886
49859
99813
3897

nicht grade toll. Ich habe aber grade nur diesen dämlichen Compiler da. *heul*. Könnte mal jemand den Code hier ausprobieren:

#include <iostream>   
#include <cmath>      
#include <ctime>      
#include <fstream>    
#include <algorithm>
#include <functional>
#include <limits>
#include <sstream>    
#include <deque>
#ifndef NO_VECTOR
#include <vector>
#endif

using namespace std;

inline const string to_string(int x)
{
   stringstream tmp;
   tmp << x;
   return tmp.str();
}

#ifdef WIN32
#  include <windows.h>
#  ifdef _MSC_VER 
#    undef max
#  endif
#else
#  include <sys/time.h>
#endif

int main()
{
#ifdef WIN32
   DWORD times[7];  
#else
   struct timeval times[7];
   struct timezone tz;
#endif
   const size_t arrayLength=5000000;  
   size_t i=0;

   //Arrays erzeugen  
#ifdef WIN32
   times[0] = GetTickCount();
#else
   gettimeofday(×[0], &tz);
#endif
#ifdef NO_VECTOR
   int * intArray=new int[arrayLength];
   double * doubleArray=new double[arrayLength];
#else
   vector<int> intArray(arrayLength);
   vector<double> doubleArray(arrayLength);
#endif
#ifdef WIN32
   times[1] = GetTickCount();
#else
   gettimeofday(×[1], &tz);
#endif

   cout << "Array erzeugt" << endl;

   //Zufallszahlen
   srand( (unsigned int)0 );
   for(;i<arrayLength;++i)
   {
      intArray[i]    = static_cast<int>(std::numeric_limits<int>::max() * rand() / RAND_MAX + 1.0);
      doubleArray[i] = (std::numeric_limits<double>::max() * rand() / RAND_MAX + 1.0);
   }
#ifdef WIN32
   times[2] = GetTickCount();
#else
   gettimeofday(×[2], &tz);
#endif

   cout << "Zufallszahlen erzeugt" << endl;

   //Sortieren
#ifdef NO_VECTOR
   sort(&intArray[0], &intArray[arrayLength-1]);
#else
   sort(intArray.begin(), intArray.end());
#endif
#ifdef WIN32
   times[3] = GetTickCount();
#else
   gettimeofday(×[3], &tz);
#endif

   cout << "Sortiert" << endl;

   //int to char

   deque<string> schlange;
   ostringstream stringBuffer;

   for(i=0; i<arrayLength; ++i)
   {
      schlange.push_back(to_string(intArray[i]));
      schlange.push_back("\n");
   }
#ifdef WIN32
   times[4] = GetTickCount();
#else
   gettimeofday(×[4], &tz);
#endif

   cout << "An String angehaengt" << endl;

   //string in Datei schreiben
   ofstream out("demo.txt");
   if(!out.is_open())
   {
      std::cerr << "Fehler" << std::endl;
#ifdef NO_VECTOR
      delete[] intArray;
      delete[] doubleArray;
#endif
      return 1;
   }

   for (deque<string>::iterator it = schlange.begin(); it != schlange.end(); ++it)
      out << *it;

   out.close();
#ifdef WIN32
   times[5] = GetTickCount();
#else
   gettimeofday(×[5], &tz);
#endif

   cout << "In Datei geschreiben" << endl;

   //Wurzeln berechnen
   for(i=0; i<arrayLength; ++i)
   {
      doubleArray[i] = sqrt(doubleArray[i]);
   }

#ifdef WIN32
   times[6] = GetTickCount();
#else
   gettimeofday(×[6], &tz);
#endif

   cout << "Wurzeln berechnet" << endl;

   //Ausgabe:
#ifdef WIN32
   cout << "Array erzeugen: " 
      << (times[1] - times[0])
      << std::endl;
   cout << "Zufallszahlen erzeugen: "
      << (times[2] - times[1])
      << std::endl;
   cout << "Sortieren: "
      << (times[3] - times[2])
      << std::endl;
   cout << "String anhaengen: "
      << (times[4] - times[3])
      << std::endl;
   cout << "Speichern: "
      << (times[5] - times[4])
      << std::endl;
   cout << "Wurzeln berechnen: "
      << (times[6] - times[5])
      << std::endl;
#else
   cout << "Array erzeugen: " 
      << (times[1].tv_usec - times[0].tv_usec)
      << std::endl;
   cout << "Zufallszahlen erzeugen: "
      << (times[2].tv_usec - times[1].tv_usec)
      << std::endl;
   cout << "Sortieren: "
      << (times[3].tv_usec - times[2].tv_usec)
      << std::endl;
   cout << "String anhaengen: "
      << (times[4].tv_usec - times[3].tv_usec)
      << std::endl;
   cout << "Speichern: "
      << (times[5].tv_usec - times[4].tv_usec)
      << std::endl;
   cout << "Wurzeln berechnen: "
      << (times[6].tv_usec - times[5].tv_usec)
      << std::endl;
#endif

#ifdef NO_VECTOR
   delete[] intArray;
   delete[] doubleArray;
#endif

   return 0;
}

[Helium]

Oh fuck, der schreibt nur einsen in die Datei.

Oh mal sehen

numeric_limits<int>::max() * rand() / RAND_MAX + 1.0

int * int / int + double

die erste multiplikation kann einen überlauf erzeugen. Die division teilt durch eine Zahl, die meist numeric_limits<int>::max() entspricht, also kommt 0 raus und 0 + 1 == 1

ersetzt

numeric_limits<int>::max() * rand() / RAND_MAX + 1.0

durch

static_cast<double>(numeric_limits<int>::max()) * rand() / RAND_MAX + 1.0

dann sollte es gehen

[Gregor]

Original erstellt von Helium:
**Oh fuck, der schreibt nur einsen in die Datei.
**

BAH! ...jetzt muss ich das Programm nochmal testen!

[Gregor]

Heliums Code mit den genannten Compiler-Optionen :

Es gab noch stärkere Schwankungen, als sonst. Die Ergebnisse können also nur als Anhaltspunkt genommen werden. Die erzeugte Datei scheint mehr oder weniger die richtige Größe zu haben, allerdings enthält sie ungefähr 2,5MB zu viel (vielleicht "\r\n" statt "\n"? ...sollte aber nicht viel ausmachen)

1,2 GHz         1,6 GHz
Array                :        130             120
Zufallszahlen        :       1142             861
sortieren            :       1422            1072
String erzeugen      :     147612          110609
Speichern            :      23464           27679
Wurzel berechnen     :       1182            1052

Gerade die Werte beim Speichern und bei den Wurzeln scheinen nicht der tatsächlichen Performance zu entsprechen. Die Größenordnung sollte aber stimmen. ...bei den Wurzeln habe ich (vor den Veränderungen) aber schon Messungen gemacht, die nur etwa die halbe Zeit benötigt hatten.

[rüdiger]

mach am besten 3 Messungen und nimm den Durchschnittswert, da kann sich ja immer etwas ändern, durch swapping etc.

eigentlich wär es am besten in dem Programm den Test 3 mal zu machen, da man dann vom L2 Cache profitieren kann.