langsamer delete operator?

[Axel Panning]

Hallo,

ich hab bei einem Programm bei mir festgestellt, daß das "deleten" von
Feldern erheblich länger dauert, als das Anlegen von Feldern. p. Bei
einem Programm von mir werden oft große Datenfelder unterschiedlich er
Größe angelegt und wieder gelöscht. Daher ist dieser Umstand sehr ungünstig.

Ist das Normal, daß der Unterschied bei Faktor 10-20 liegt? Oder begehe
ich hier an irgendeiner Stelle einen grundlegenden Fehler!?

Danke für die Hilfe.

Gruß Axel

code:
QTime t;

t.start();
double** data = new double*[1300];
for (int i=0;i<1300;i++) data[i] = new double[1300];
cout << "needed to create: " << t.elapsed() << " mseconds"<<endl ;

t.start();
for (int j=0;j<1300;j++) delete [] data[j];
delete [] data;
cout << "needed to delete: " << t.elapsed() << " mseconds"<<endl ;

Programm Ausgabe (auf AthloxXP1800, kompiliert mit MS-VC6 - release,
optimiert auf Geschwindigkeit ):
needed to create: 31 mseconds
needed to delete: 484 mseconds

[Axel Panning]

Torsten Mueller schrieb:

Axel Panning <ax**@harnackst rasse.de> schrieb:

So the question in english again:

Is it normal that the creation of a datafield using the "new"
operator is approximately 10 to 20 times faster than deleting the
same? Am I mistaken any way in the code below?

Deletion is not easy. A heap object is normally located in a larger
block ob memory. This larger block contains more than one object. If a
single object is deleted the heap management must look if there are
still other objects in the same block or not to free the entire block
if possible. This happens in every single delete and this takes time.
The new is much easier.

You have large arrays with elements of the same data type. You should
try to make one large array with a two dimensional shape. Of course
you must compute the indexes of rows and columns yourself. But this
will be much faster than the multiple news and deletes.

T.M.

tried it.

-> snip
double* dataEasy = new double[arr_size*arr_si ze];
double** dataEasyAccess = new double*[arr_size];
for (int k=0;k<arr_size; k++) dataEasyAccess[k] = dataEasy + k*arr_size;

-> snap

having the same datastructure afterwards in 'dataEasyAccess '. Else i had
to change a lot of code ;).

The timings are very ok now. Thanks for the idea, but i wonder why i
dont have the results like the guys in the other postings with my old code.

Thanks a lot.

[Axel Panning]

John Carson schrieb:

"Axel Panning" <ax**@harnackst rasse.de> wrote in message
news:db******** **@online.de

Oops. forgot this is an english newsgroup .

So the question in english again:

Is it normal that the creation of a datafield using the "new" operator
is approximately 10 to 20 times faster than deleting the same? Am I
mistaken any way in the code below?

Thanks

code:
QTime t;

t.start();
double** data = new double*[1300];
for (int i=0;i<1300;i++) data[i] = new double[1300];
cout << "needed to create: " << t.elapsed() << " mseconds"<<endl ;

t.start();
for (int j=0;j<1300;j++) delete [] data[j];
delete [] data;
cout << "needed to delete: " << t.elapsed() << " mseconds"<<endl ;

Output (on AthlonXP1800, compiled with MS-VC6 - release,
speed-optimized):
needed to create: 31 mseconds
needed to delete: 484 mseconds

Running VC++7.1 on Windows XP, Pentium M 1.5Ghz, 512Mb memory, I had to
increase the dimensions by a factor of 10 to get something clearly
non-zero. I then find that the create takes at least 3 times as long as
the delete and often much longer, e.g.,

needed to create: 90 mseconds
needed to delete: 20 mseconds

factor 10??
13000*^2=169.00 0.000. multiplied by 8(double) > 1Gig. This sould cause
your pc to allocate this in temporary file. You seem to have a fast
harddisk ;)

class QTime
{
int start_, finish_;
public:
void start()
{
start_ = clock();
}
int elapsed()
{
finish_ = clock();
return (finish_-start_);
}
};

const int K = 13000;

int main()
{
QTime t;

t.start();
double** data = new double*[K];
for (int i=0;i<K;i++)
data[i] = new double[K];
cout << "needed to create: " << t.elapsed() << " mseconds"<<endl ;

t.start();
for (int j=0;j<K;j++)
delete [] data[j];
delete [] data;
cout << "needed to delete: " << t.elapsed() << " mseconds"<<endl ;
}

This is confusing to me. Only get fast results sing this code...

-> snip
double* dataEasy = new double[arr_size*arr_si ze];
double** dataEasyAccess = new double*[arr_size];
for (int k=0;k<arr_size; k++) dataEasyAccess[k] = dataEasy + k*arr_size;

-> snap

[ulrich]

On Wed, 13 Jul 2005 13:21:17 +0200, Axel Panning <ax**@harnackst rasse.de>
wrote:

I don't know that class QTime, but I have seen similar classes needed to

No it's working fine that way. It is from the Qt-Frameword
(www.trolltech.com). Is there a standard-c function to get msec's? I
never watched out befor for it. Always used the QTime class. My first
short search didnt find any.

clock() in <ctime>
and divide the result by CLOCKS_PER_SEC or CLK_TCK to get seconds.
resolution is not better than 1 ms.

[John Carson]

"Axel Panning" <ax**@harnackst rasse.de> wrote in message
news:db******** **@online.de

This is confusing to me. Only get fast results sing this code...

-> snip
double* dataEasy = new double[arr_size*arr_si ze];
double** dataEasyAccess = new double*[arr_size];
for (int k=0;k<arr_size; k++) dataEasyAccess[k] = dataEasy +
k*arr_size;

I don't know what explains it. I tried using VC++ 6.0 on both NT4 and XP and
I still get create taking a lot more time than delete.

--
John Carson