Iteration Performance abhängig von Objektgröße?

unskilled

Joar, sry - ist mir vorhin (nat. erst als ich meinen Post noch ma durchgelesen hatte) auch aufgefallen xD

Tachyon

BorisDieKlinge schrieb:

naja wenn data 150 groß ist, oder nur 16 variert es um 80ms... release.. VC++ 2003

Ich habe null Unterschied, selbst, wenn data mal 10 und mal 5000 groß ist.

BorisDieKlinge

hmm komsich da muss ich wohl mal bischen tiefer rein schaun;)

camper

double d= (*it)->dDATA[0];

Sinnlos, kann unmittelbar wegoptimiert werden, da d nicht weiter benutzt wird. Wird es nicht wegoptimiert (z.B. wegen)

d+= (*it)->dDATA[0];

(und irgendwo am Ende ausgeben) - wird man dagegen eine Abhängigkeit der Größe von dData und dem vector feststellen, einfach wegen begrenzter Speicherbandbreite.

unskilled

verdammt - da haste nat. recht xD

double d (0);
    for(size_t k (0); k != COUNT_MAX; ++k)
		{
			const std::list<Foo*>::iterator end (lDat.end());
			for(std::list<Foo*>::iterator it = lDat.begin(); it != end; ++it)
				{
					d += (*it)->dDATA[0]; 
				}
	    }
	std::cout << d << std::endl; //oder iwas anders mit d machen

=>

#define ARRAY_MAX 10000
#define COUNT_MAX 100

#define DOUBLE_ARRAY_LENGHT 1
=> 3
#define DOUBLE_ARRAY_LENGHT 10000
=> 9

bb

BorisDieKlinge

hmm jetzt müsste man mal testen wie sie die performanteverhälte beim einfügen und löschen von foo pointern in der liste

unskilled

hf : P

BorisDieKlinge

Soo hier hab ich ne modifizierte Version. ich füge Foo Pointer in eine Liste hinzu, (kopiere von lDat nach lDatDest, und lösche lDatDest wieder..

Size 1 Time: 2094
Size 2 Time: 1127
Size 4 Time: 2134
Size 8 Time: 938
Size 16 Time: 1513
Size 32 Time: 2383
Size 64 Time: 2248
Size 128 Time: 2455
Size 256 Time: 2474
Size 512 Time: 2462
Size 1024 Time: 2459
Size 2048 Time: 2498
Size 4096 Time: 761
Size 8192 Time: 1303
Size 16384 Time: 599
Size 32768 Time: 1223
Size 65536 Time: 312

class Foo{
public:
	double dDATA[1];

};

int _tmain(int argc, _TCHAR* argv[])
{

	std::vector<Foo> vDat(1000);

	std::list<Foo*> lDat;

	std::list<Foo*> lDatDest;

	for(int i=0; i< 1000; i++)
		lDat.push_back(&vDat[i]);

	long lStart= timeGetTime();

	for(int k=0; k< 100; k++){

		//lDat Foo Pointer in lDatDest kopieren
		for(std::list<Foo*>::iterator it = lDat.begin(); it != lDat.end(); it++)
			lDatDest.insert(lDatDest.begin(), (*it));

		//Und wieder löschen
		while(lDatDest.size())
			lDatDest.erase(lDatDest.begin());

	}
	std::cout << "Time: " << (timeGetTime()-lStart) << std::endl;
	return 0;
}

was ist da los? ich kopiere doch nur POINTER nicht die objekte...

BorisDieKlinge schrieb:

hmm jetzt müsste man mal testen wie sie die performanteverhälte beim einfügen und löschen von foo pointern in der liste

Also wenn du genauso Quellcode schreibst, wie du es hier mit Saetzen der deutschen Sprache versuchst, dann will ich nie ein Programm bestehend aus mehr als 2 Dateien und/oder 500 Zeilen Quellcode von dir sehen...

BorisDieKlinge

Schön für dich, wenn du jetzt was zur Ursache des Problem sagen könntest, dann hätte ich respekt

simon.gysi

was ist da los? ich kopiere doch nur POINTER nicht die objekte...

Da werden nodes der list angelegt und wieder freigegeben (mit new und delete) und das ist teuer.

BorisDieKlinge

ja gut, aber es werde nodes welche immer die gleiche größe haben mit new und delet e erzeugt und gelöscht ... dann düfte es keinen unterschied machen wie groß das objekt ist auf das ein pointer zeigt.

Tachyon

BorisDieKlinge schrieb:

Soo hier hab ich ne modifizierte Version. ich füge Foo Pointer in eine Liste hinzu, (kopiere von lDat nach lDatDest, und lösche lDatDest wieder..

Size 1 Time: 2094
Size 2 Time: 1127
Size 4 Time: 2134
Size 8 Time: 938
Size 16 Time: 1513
Size 32 Time: 2383
Size 64 Time: 2248
Size 128 Time: 2455
Size 256 Time: 2474
Size 512 Time: 2462
Size 1024 Time: 2459
Size 2048 Time: 2498
Size 4096 Time: 761
Size 8192 Time: 1303
Size 16384 Time: 599
Size 32768 Time: 1223
Size 65536 Time: 312

class Foo{
public:
	double dDATA[1];

};

int _tmain(int argc, _TCHAR* argv[])
{

	

	std::vector<Foo> vDat(1000);

	std::list<Foo*> lDat;

	std::list<Foo*> lDatDest;

	for(int i=0; i< 1000; i++)
		lDat.push_back(&vDat[i]);

	long lStart= timeGetTime();

	for(int k=0; k< 100; k++){
		
		//lDat Foo Pointer in lDatDest kopieren
		for(std::list<Foo*>::iterator it = lDat.begin(); it != lDat.end(); it++)
			lDatDest.insert(lDatDest.begin(), (*it));

		//Und wieder löschen
		while(lDatDest.size())
			lDatDest.erase(lDatDest.begin());

	
	}
	std::cout << "Time: " << (timeGetTime()-lStart) << std::endl;
	return 0;
}

was ist da los? ich kopiere doch nur POINTER nicht die objekte...

Entweder, Dein Rechner ist sehr lahm, oder Du startest immer einen Debug-Build.
Bei mir dauert es, völlig unabhängig von der Größe, immer ca. 60ms.
Wenn Du MSVC benutzt, dann drücke mal Strg+F5, anstatt immer auf das grüne Dreieck zu klicken.