delete beschleunigen

asc

janmerkschien schrieb:

ich werde jetzt mal std::vector und std::list ausprobieren und dann mein ergebnis nochmal posten

Wenn du std::vector verwendest, solltest du diesen aber schon auf eine realistische Größe vorresservieren (Damit er nur selten umkopiert wird).

Beispiel:

std::vector<int> intvector;
intvector.reserve(50000);

janmerkschien

hier ist der code bei dem ich im release modus 5,5 sekunde brauche ...

#include "stdafx.h"
#include "windows.h"
#include "stdio.h"
#include <string>
#include <iostream>
#include "math.h"

using namespace std;

int main(int argc, char* argv[])
{
  struct Data{
  char point[128];
  long rec;
  int b;
  double b1,b2,b3;
  long L;
  char c1,c2,c3,c4;
  Data *next;
  };

  Data *first = new Data;
  Data *last = new Data;
  first=NULL;
  last = NULL;
  for(long i=0; i<99998; i++){
    if(first==NULL){
      first = new Data;
      if(first){
          first->next=NULL;
          strcpy(first->point,"bla");
          first->rec = 10;
          first->b = 0;
          first->b1 = 1;
          first->b2 = 2;
          first->b3 = 3;
          first->L = 7;
          first->c1 = 'A';
          first->c2 = 'B';
          first->c3 = 'C';
          first->c4 = 'D';
          last = first;
      }
    } else {
      Data *d = first;
      if(last==NULL)
        while(d->next) d=d->next;
      else
        d=last;
      d->next=new Data;
      if(d->next)
      {
        d->next->next=NULL;     
        strcpy(d->point,"bla");
        d->next->rec = 10;
        d->next->b = 0;
        d->next->b1 = 1;
        d->next->b2 = 2;
        d->next->b3 = 3;
        d->next->L = 7;
        d->next->c1 = 'A';
        d->next->c2 = 'B';
        d->next->c3 = 'C';
        d->next->c4 = 'D';
        last = d->next;
      }
    }
  }

	//Variablen
  LONGLONG g_Frequency, g_FirstNullCount, g_LastNullCount, g_FirstCount, g_LastCount;

  //Frequenz holen
  if (!QueryPerformanceFrequency((LARGE_INTEGER*)&g_Frequency))
    printf("Performance Counter nicht vorhanden");

	double resolution = 1000000 / ((double)g_Frequency);

	printf("Frequenz des Counters:  %lld kHz\n", g_Frequency/1000);  //lld -> LONGLONG darstellung
	printf("Dadurch maximale Aufloesung: %4.5f us\n", resolution);

	//null-messung
	QueryPerformanceCounter((LARGE_INTEGER*)&g_FirstNullCount);
	QueryPerformanceCounter((LARGE_INTEGER*)&g_LastNullCount);
	double nulltime = (((double)(g_LastNullCount-g_FirstNullCount))/((double)g_Frequency)); 

	printf("Null-Zeit: %4.5f us\n", nulltime * 1000000);

	//beginn messung
	QueryPerformanceCounter((LARGE_INTEGER*)&g_FirstCount);

  ////////////DESTRUKTOR/////////////////////
  Data *d=first,*d2;
  while(d){
    d2=d->next;
    delete(d);
    d=d2;
  }

	//2. Messung
  QueryPerformanceCounter((LARGE_INTEGER*)&g_LastCount);
  double dTimeDiff = (((double)(g_LastCount-g_FirstCount))/((double)g_Frequency)); 

	//Von der gemessenen Zeit die "Null-Zeit" abziehen, um genauer zu werden
	double time = (dTimeDiff - nulltime) * 1000000; //mikro-sekunden

	printf("Zeit: %4.5f us\n" ,time);

	//warten auf tastendruck
	string dummy;
	getline(cin, dummy);

	return 0;
}

@asc:
ja bin gerade bei den vector dranne aber wie kann ich den denn jetzt löschen ohne memory leaks??
delete vector; geht ja leider nicht

MFK

janmerkschien schrieb:

hier ist der code bei dem ich im release modus 5,5 sekunde brauche ...

Vielleicht solltest du das Programm mal ohne Debugger starten...

Ethon

Ich hab deinen Messcode weggelöscht und nur Aufbauen & Zerstören der Liste übrig gelassen und mit GCC kompiliert.
Die Ausführungszeit (mitsamt Prozesserstellung) beläuft sich auf gerade mal 50ms, sämtliche Optimierungen deaktiviert. (Irgendein alter AMD Phenom Quadcore)

ja bin gerade bei den vector dranne aber wie kann ich den denn jetzt löschen ohne memory leaks??
delete vector; geht ja leider nicht

Das macht der von alleine, manuell mit delete rumfuchteln tut man in C++ praktisch nie. Statt new[] und delete[] verwendet man std::vector, der selbst aufräumt. Statt delete verwendet man Smart-Pointer, zb std::shared_ptr oder std::unique_ptr.

So könnte dein Beispiel mit nem vector aussehen:

#include <cstring>
#include <vector>

int main(int argc, char* argv[])
{
    struct Data
    {
        char point[128];
        long rec;
        int b;
        double b1,b2,b3;
        long L;
        char c1,c2,c3,c4;
    };

    std::vector<Data> data(99998);
    for(long i=0; i<99998; i++)
    {
        Data cur;
        strcpy(cur.point,"bla");
        cur.rec = 10;
        cur.b = 0;
        cur.b1 = 1;
        cur.b2 = 2;
        cur.b3 = 3;
        cur.L = 7;
        cur.c1 = 'A';
        cur.c2 = 'B';
        cur.c3 = 'C';
        cur.c4 = 'D';

        data[i] = cur;
    }
}

Shade Of Mine

janmerkschien schrieb:

hier ist der code bei dem ich im release modus 5,5 sekunde brauche ...

Messung am beste über Profiler.

Aber der Code ist ansonsten OK. Dein Problem ist mit 99% wahrscheinlichkeit dass du aus der IDE heraus startest und den Debugger an den Prozess dran hängst. Dadurch sind Memory Operationen furchtbar langsam.

Starte die EXE einfach mal aus dem Explorer heraus und schaue ob du die selben Zahlen bekommst.

ja bin gerade bei den vector dranne aber wie kann ich den denn jetzt löschen ohne memory leaks??
delete vector; geht ja leider nicht

vector löscht automatisch wenn er out-of-scope geht, dh wenn die Variable aufhört zu existieren, wird auch der Speicher gelöscht.

SeppJ

So etwas wird ernsthaft in produktivem Code benutzt? Wieso bilde ich mich überhaupt noch weiter, anstatt bei euch den Laden zu schmeißen?

Wie auch immer:

#include <string>
#include <iostream>
#include <ctime>
#include <list>
#include <iomanip>

using namespace std;

struct Data{
  string point;
  long rec;
  int b;
  double b1,b2,b3;
  long L;
  char c1,c2,c3,c4;
  Data(string point, long rec, int b, double b1, double b2, double b3, long L, char c1, char c2, char c3, char c4):
    point(point), rec(rec), b(b), b1(b1), b2(b2), b3(b3), L(L), c1(c1), c2(c2), c3(c3), c4(c4){}
};

int main()
{
  volatile time_t start, end;

  {
    list<Data> liste;

    for(long i=0; i<9999980; i++)
      liste.push_back(Data("bla", 10 ,0 ,1, 2, 3, 7, 'A', 'B', 'C', 'D'));

    cout << "Anti-Optimierungsmaßnahme: " << liste.back().point << liste.front().point << '\n';

    start = clock();
  } // Destruktor

  end = clock();  

  cout << "Zeit: " << setprecision(3) << (1.0*end - start) / CLOCKS_PER_SEC << " Sekunden.\n";
}

Beachte, dass ich die Anzahl der Elemente um einen Faktor 10 vergrößert habe, damit überhaupt etwas messbares rauskommt!

Zeit auf normalem Desktopsystem: knapp 0.6 Sekunden.

Mit vector statt list: knapp 0.4 Sekunden

Mit Strings fixer Länge (wie du es schon hattest): 0.13 Sekunden.

janmerkschien

das passiert wenn man seinem chef blind vertraut ..
wieder was fürs leben gelernt ...
wenn ich es als exe ausführe geht das ganze schnell genug
tut mir leid das ich euch allen zeit geraubt habe ...
nochmal vielen dank an alle

krümelkacker

SeppJ schrieb:

struct Data{
  string point;
  long rec;
  int b;
  double b1,b2,b3;
  long L;
  char c1,c2,c3,c4;
  Data(string point, long rec, int b, double b1, double b2, double b3, long L, char c1, char c2, char c3, char c4):
    point(point), rec(rec), b(b), b1(b1), b2(b2), b3(b3), L(L), c1(c1), c2(c2), c3(c3), c4(c4){}
};

Den Konstruktor hätte ich mir wahrscheinlich zugunsten der "Aggregat-Initialisierung" gespart.

SeppJ

krümelkacker schrieb:

Den Konstruktor hätte ich mir wahrscheinlich zugunsten der "Aggregat-Initialisierung" gespart.

Ich wollte streng C++98 kompatibel bleiben, das mag das nicht so gern, wenn man list-Elemente so initialisiert.

Besser wäre: Eine Klasse sollte niemals so aussehen. 11 unabhängige Member ist verdächtig viel und die Namensgebung deutet darauf hin, dass sie gar nicht unabhängig sind.

314159265358979

lol @ Produktivcode