3. Iteration Performance abhängig von Objektgröße?

Iteration Performance abhängig von Objektgröße?

  • B

    Hallo Leute,

    ich hab da ne anomalie endeckt. Ich hab eine klasse X,

    ich lege meientwegen 10000 objekt von X in einen std::vector an.

    parallel hab ich eine std::list welche Zeiger auf die X Objekte aus dem vector enthält.

    std::vector<X> v;
std::list<X*> l;

    wenn ich nun die Liste iteriere oder X Pointer einfüge lösche etc. geht es um nen fackt 20% schneller wenn die class X mehr oder weniger member variablen hat.

    Kann mir das einer erklären.

    Die objekte sind ja da im vector, die liste verwaltet nur pointer auf die Objekte.. aber je nach größe der Objekte ist die berabeitunggeschwindigkeit in der liste langsamer???? 😕
    kam zufällig darauf als ich einen nicht mehr genutzen member variable aus X auskommentierte und plötzlich war das ding langsamer???

    Hat das was mit padding zu tun oder? Pointeraritmetik? Cache?

    wenn ich mal lustiger halbe paar double werte in die klasse einbaue, wird das ding noch schneller... sind es zviel wirds wieder langsamen.. bis zu faktor 2,5 performanceunterschiede

    0
  • T

    Release-Version übersetzen?

    0
  • B

    hab ich:) das ist echt krass... hab mal bischen rumgespielt.. die iterationgeschwindigkeit ändert sich enorm je nachdem wie groß die klasse wird (also anzahl der membervariablen) .. wenn ich zuviele reinmache wirds wieder langsame.. da gibt also ne optimal größe wo das ding am schneller läuft.. muss doch am cache liegen oder so

    wenn ich bspw. ein std::vector<BYTE> iteriere oder ein std::vector<UINT> , ist der mit UINT schneller, aber das liegt ja an der bitbreite der CPU

    0
  • T

    Wie viel Inhalt hat denn Deine Liste insgesamt? Muss er evtl. schon swappen?

    0
  • B

    naja bisher hat die liste nur ca. 50 elemente. hab halt ne schleife in der ich die list immer wieder iteriere ! was meinst du mit liste swapen?

    0
  • T

    Ich meine den Speicher, den Dein Programm allokiert, wenn Du die Liste gefüllt hast.
    Wie wäre es mal mit Code?

    Außerdem sagst Du, Deine Liste hält nur Pointer. Die sind eh immer gleich groß, egal wie groß Deine X-Objekte selbst sind. Irgendwas ist da mal wieder komisch, bei Dir.
    Und ist wirklich auch das iterieren langsamer? Oder nur das Einfügen/Löschen?

    0
  • ?

    Poste mal ein Codebeispiel mit dem man das nachvollziehen kann.

    0
  • B

    dazu müsste ich zuviel code posten... ich mach mal ne testumgebung.. und testes es ohne das drumherum.. wenns dann immer noch so ist, dann poste ich den code:)

    0
  • B
     

    #include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <vector>
#include <list>

class Foo{
public:
	double dDATA[40];

};

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

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

	std::list<Foo*> lDat;

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

	long lStart= timeGetTime();

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

		for(std::list<Foo*>::iterator it = lDat.begin(); it != lDat.end(); it++)
			double d= (*it)->dDATA[0];

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

    so jung, verändert mal die größe von dDATA[40] 😉

    dDATA[8] = 748ms
    dDATAT[16]= 865ms

    sind immerhin 110ms .. das kann ja nich an der zeitmessung toleranz liegen

    0
  • D

    Ja, in so einem Fall ist es besser/schneller Pointer auf die Objekte in der Liste zu speichern.

    0
  • B

    ja das mach ich ja, trozdem variert die iterationgeschwindigkeit;)

    0
  • ?

    Also im Releasemode hab ich da immer 0ms.
    Wenn ich es mit 10000 Durchgängen mache

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

        for(std::list<Foo*>::iterator it = lDat.begin(); it != lDat.end(); it++)
            double d= (*it)->dDATA[0];

    }

    dann hab ich
    8: Time: 640
    16: Time: 640
    16000: Time: 641

    Mach mal mehr Durchgänge, dann wird der prozentuale Unterschied nicht mehr so groß sein.

    dust schrieb:

    Ja, in so einem Fall ist es besser/schneller Pointer auf die Objekte in der Liste zu speichern.

    Beim iterieren? Wie kommst du darauf?

    0
  • L

    Also ich kann im Releasemodus vom VC++ 2005 keine Unterschiede messen, selbst wenn ich die Anzahl der Iterationen verhundertfache (sonst kommen zwischen 0 und 15 ms raus).

    0
  • T

    Jup, bei mir auch. 0ms im Release Build.

    0
  • U

    also ich habs ma ein klein wenig abgeändert...

    #include <iostream> 
#include <vector> 
#include <list> 
#include <ctime>

#define DOUBLE_ARRAY_LENGHT 100
#define ARRAY_MAX 10000
#define COUNT_MAX 100

/* "Messwerte", 32bit vista, vs 2005 team suite, release mode
40, 10000, 100:
	32
	25
	27
	27
	18
	23
	20
	21
	=> 193 / 8
100, 10000, 100:
	17
	30
	52
	21
	16
	20
	19
	20
	=> 195 / 8
*/

struct Foo
	{ 
		double dDATA[DOUBLE_ARRAY_LENGHT]; 
	}; 

int main (int argc, char* argv[]) 
{ 
    std::vector<Foo> vDat (ARRAY_MAX); 
    std::list<Foo*> lDat;

    for(size_t i=0; i != ARRAY_MAX; i++) 
        lDat.push_back(&vDat[i]); 

	clock_t first = 0;
	clock_t second = 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)
				{
					first += clock();
					double d= (*it)->dDATA[0]; 
					second += clock();
				}
	    }
    std::cout << "Clock: " << static_cast <double> (second - first) << std::endl; 
	return 0; 
}

    bb 😛

    PS: auch bei DOUBLE_ARRAY_LENGTH == 1000 werden die Werte bei mir nicht größer - habs zwar au nicht aufgerechnet oder so, aber die Zahlen bewegten sich wieder in dem Bereich

    EDIT:
    sry, so wie oben is das bissl doof ^^

    Habs so gemacht: Ergebnis:

    clock_t second = 0;
	clock_t first = clock ();
    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)
				{
					double d = (*it)->dDATA[0]; 
				}
	    }
	second = clock ();

    Hab DOUBLE_ARRAY_LENGHT == 1 und == 10000 gewählt - beide Male kam immer 3 raus.

    bb

    0
  • B

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

    0
  • B
     

    clock_t first = 0;
    clock_t second = 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)
                {
                    first += clock();
                    double d= (*it)->dDATA[0];
                    second += clock();
                }
        }
    std::cout << "Clock: " << static_cast <double> (second - first) << std::endl;

    solltest du clock frist nich über die schleif setzen, und second drunter?

    0
  • U

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

    0
  • T

    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.

    0
  • B

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

    0
Anmelden zum Antworten