Optimierung von C++ Code in asm



  • Hallo, ich habe hier folgenden Code:

    void Engine::RefreshGridAdd(Particle* P1, Sector* SectorSelected)
    {
    	if (SectorSelected->ParticleCount < SECTOR_PARTICLE_MAXIMUM)
    		SectorSelected->Particles[SectorSelected->ParticleCount++] = P1;
    }
    void Engine::RefreshGridRemove(Particle* P1, Sector* SectorSelected)
    {
    	for (unsigned short i = 0; i < SectorSelected->ParticleCount; i++)
    		if (SectorSelected->Particles[i] == P1)
    		{
    			SectorSelected->ParticleCount--;
    			if (i < (SectorSelected->ParticleCount + 1))//Es muss sortiert werden wenn das eintrifft!
    				SectorSelected->Particles[i] = SectorSelected->Particles[SectorSelected->ParticleCount];
    			return;
    		}
    }
    //2. Interaction Passus 2 (Parallel)
    void Engine::SimulateInteraction(void)
    {
    	Concurrency::parallel_for(0, (int)ParticleCount, [&](int i)
    	{
    		Particle *P1 = *PSorted[i];//etwas leistungsverlust
    		//Particle *P1 = PReal[i];//dereferenzierung
    
    		InteractionCollision(P1);
    		InteractionAdhäsion(P1);
    	});
    }
    

    Dieser nimmt sehr viel Rechenpower und ich wollte mal fragen, ob jemand hier im Forum zufällig weiß wie ich das in asm optimieren kann? 🙂



  • Wo genau liegt das Bottleneck?



  • Hallo,

    Ich gehe jetz ersteinmal davon aus, dass dein Beitrag Ernst gemeint ist. Der code den du geposted hast mach selber recht wenig (der Compiler wird mit 99,99999% warscheinlichkeit besseren Code erzeugen als du).

    Ich wuerde darauf wetten, dass das Problem irgendwo hier liegt

    InteractionCollision(P1);
    InteractionAdhäsion(P1);

    Ohne die implementation zu sehen kann man relativ wenig dazu sagen. Der Rest sollte eigentlich in microsekunden ausgefuert werden.

    ...



  • Hi,
    ich kann hoffentlich mal ein par Details ergänzen.
    Arbeite ebenfalls an dem selben Projekt 😛
    http://fragilitas-game.blogspot.de/

    Das Problem ist weniger ein Bottleneck. Der Code wird sehr oft aufgerufen, es ist eine Performance relevante Stelle. Er muss ~3 millionan mal in der Sekunde aufgerufen werden, wenn ich mich gerade nicht verrechne.

    Es werden die Partikel-Zeiger in einem Grid zur Kollisionserkennung aktualisiert / sortiert.

    Viele Grüße



  • Ich kenne Euer Projekt nicht im Detail.
    Aber eine Frage: in der Methode RefreshGridRemove sucht Ihr ein Element P1
    in einem Array sectorSelected->Particles, und zwar linear.
    Falls dieses Array extrem gross ist, wäre es nicht ein lohnender Ansatz,
    über eine Map nachzudenken?
    Im Fall einer Hashmap ist der Zugriff im besten Fall direkt ( O(1) ),
    also wenn man den linearen Worst-Case eines Arrays von 1 000 Elementen
    nimmt, hat man 1 000 Zugriffe, im Best-Case einer Hashtable nur einen.
    Hash-Kollisionen sind selten und die Hashfunktion oft extrem effizient.
    Selbst eine Baum-Map hätte mit ihrer logarithmischen Zugriffszeit immer
    noch ein besseres Laufzeitverhalten als eine lineare Suche.
    Ok, klar der Preis ist das Einfügen in die Map - aber vielleicht
    lohnt sich in eurem Fall ja der Tradeoff? Ist nur ein Vorschlag.
    Also das wäre der Punkt, an dem ich ansetzen würde, nämlich bei der
    Algorithmik und nicht bei der Sprache.
    Wie bereits richtig erwähnt wurde, die meisten C++ Compiler sind
    viel besser im Optimieren als der durchschnittliche C++-Programmierer.


Log in to reply