Performance-Rangliste einiger Funktionen

Helishcoffe · 23. Mai 2017

Da ich immer versuche darauf zu achten, dass mein Spiel flüssig und gut läuft, versuche ich immer Performancetötende Funktionen zu meiden bzw. sie so selten wie möglich einzusetzen. Deswegen hatte ich einfach mal die Idee, alle gängigen Funktionen von denen man Oft gebrauch macht auf ihre Performance zu untersuchen.

Das hier ist kein professioneller Test oder was auch immer. Ich möchte die jenigen, die vielleicht gerade mit Unity anfangen, eine kleine Übersicht geben welche Funktionen man doch besser lieber nicht jeden Frame aufrufen sollte.

Excel-Tabelle: Rangliste 24.05.2017.xlsx

Testablauf:

Die zu testende Funktion wird 1.000.000 Mal pro Frame aufgerufen und die CPU-Zeit die dafür benötigt wird notiert. Dies würde bei der Funktion Vector3.Distance folgendem Script entsprechen:

using UnityEngine;
public class Test : MonoBehaviour 
{
	void Update ()
    {        
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for(int i = 0; i < 10000000; i++)
        {
            Vector3.Distance(v1, v2);
        }       
	}
}

Im Stats Monitor lese ich dann die CPU-Zeit ab und trage sie in einer Tabelle ein.

Mein PC:

Grafikkarte: AMD Radeon 7850
Prozessor: AMD Phenom II 4x (3,4 GHz)
RAM: 8 GB DDR2

So nachdem nun die Umstände geklärt sind, hier die Liste (Absteigend sortiert, beginnend mit der Performancelastigsten Methode):

--------------------------------------------------------------------------------------------------------------------------------------------

GameObject.CreatePrimitive, GameObject.Instantiate, new GameObject, GameObject.Destroy... (>10.000 ms)

Diese Funktion nimmt sehr viel Resourcen auf sich. Ist aber auch in Ordnung so, da das Erstellen von neuen GameObjects auch eigentlich nichts ist, was man hunderte Male pro Sekunde macht. Ich wollte es aber auf Grund der Vollständigkeit mit in diese Liste aufnehmen

    void Update ()
    {      
        for (int i = 0; i < 10000; i++)
        {
            GameObject.CreatePrimitive(PrimitiveType.Plane);
        }
	}

(Getestet mit 10.000 Durchläufen Pro Frame: 960 ms. Hochgerechnet auf 1.000.000: 96.000 ms)

GameObject.FindGameObjectOfType / GameObject.FindGameObjectsOfType (> 10.000) bei einer Szene mit 200 GameObjects

    void Update ()
    {      
        for (int i = 0; i < 1000000; i++)
        {
            GameObject.FindObjectOfType(typeof(Transform));
        }
	}

GameObject.Find (6.800 ms) bei einer Szene mit 200 GameObjects

    void Update ()
    {      
        for (int i = 0; i < 1000000; i++)
        {
            GameObject.Find("SomePepper");
        }
	}

Vector3.SmoothDamp (810 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);
        Vector3 v3 = Vector3.zero;

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.SmoothDamp(v1, v2, ref v3, 0.235F);
        }
	}

Physics.SphereCastAll (650 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.SphereCastAll(v1, 0.235F, v2);
        }
	}

Physics.CapsuleCastAll (600 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(1, 0, 0);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.CapsuleCastAll(v1, v2, 0.235F, v3);
        }
	}

Physics.BoxCastAll (580 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.BoxCastAll(v1, v2, v3);
        }
	}

GameObject.FindGameObjectsWithTag (540 ms) bei einer Szene mit 200 GameObjects

    void Update ()
    {      
        for (int i = 0; i < 1000000; i++)
        {
            GameObject.FindGameObjectsWithTag("SomePepper");
        }
	}

Physics.OverlapCapsule (510 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.OverlapCapsule(v1, v2, 0.235F);
        }
	}

Vector3.Angle (480 ms)

	void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);


        for(int i = 0; i < 1000000; i++)
        {
            Vector3.Angle(v1, v2);
        }
	}

Physics.OverlapBox(480 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Quaternion q1 = new Quaternion(123, 456, 789, 1.0F);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.OverlapBox(v1, v2, q1);
        }
	}

Physics.RaycastAll (480 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.RaycastAll(v1, v2);
        }
	}

Physics.OverlapSphere (450 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.OverlapSphere(v1, 0.235F);
        }
	}

Physics.CapsuleCast (420 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(1, 0, 0);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.CapsuleCast(v1, v2, 0.235F, v3);
        }
	}

Physics.BoxCast (410 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.BoxCast(v1, v2, v3);
        }
	}

Physics.SphereCast (380 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        RaycastHit result;

        for (int i = 0; i < 1000000; i++)
        {
            Physics.SphereCast(v1, 0.235F, v2, out result);
        }
	}

Physics.SphereCastNonAlloc (350 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(1, 0, 0);

        RaycastHit[] result = new RaycastHit[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.SphereCastNonAlloc(v1, 0.235F, v2, result);
        }
	}

Physics.CapsuleCastNonAlloc (320 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(1, 0, 0);

        RaycastHit[] rh1 = new RaycastHit[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.CapsuleCastNonAlloc(v1, v2, 0.235F, v3, rh1);
        }
	}

Physics.OverlapCapsuleNonAlloc (310 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        Collider[] results = new Collider[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.OverlapCapsuleNonAlloc(v1, v2, 0.235F, results);
        }
	}

Vector3.MoveTowards (280 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.MoveTowards(v1, v2, 0.235F);
        }
	}

Physics.BoxCastNonAlloc (280 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(1, 0, 0);

        RaycastHit[] rh1 = new RaycastHit[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.BoxCastNonAlloc(v1, v2, v3, rh1);
        }
	}

Vector3.ProjectOnPlance (280 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.ProjectOnPlane(v1, v2);
        }
	}

Physics.CheckCapsule (270 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.CheckCapsule(v1, v2, 0.235F);
        }
	}

Vetcor3.ClampMagnitude (250 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);

        for(int i = 0; i < 1000000; i++)
        {
            Vector3.ClampMagnitude(v1, 100);
        }
	}

Physics.Raycast (240 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.Raycast(v1, v2);
        }
	}

GameObject.Find (240 ms) bei einer Szene mit 1 GameObject

    void Update ()
    {      
        for (int i = 0; i < 1000000; i++)
        {
            GameObject.Find("SomePepper");
        }
	}

Physics.OverlapBoxNonAlloc (230 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Quaternion q1 = new Quaternion(123, 456, 789, 1.0F);

        Collider[] results = new Collider[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.OverlapBoxNonAlloc(v1, v2, results, q1);
        }
	}

Physics.Linecast (230 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.Linecast(v1, v2);
        }
	}

Physics.RaycastNonAlloc (210 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);

        RaycastHit[] result = new RaycastHit[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.RaycastNonAlloc(v1, v2, result);
        }
	}

Physics.CheckBox (210 ms)

    
    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(123, 456, 789);
        Vector3 v3 = new Vector3(1, 0, 0);
        Quaternion q1 = new Quaternion(123, 456, 789, 1.0F);

        for (int i = 0; i < 1000000; i++)
        {
            Physics.CheckBox(v1, v2, q1);
        }
	}

Vector3.Project (210 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Project(v1, v2);
        }
	}

GameObject.FindGameObjectWithTag (200 ms) bei einer Szene mit 200 GameObects

    void Update ()
    {      
        for (int i = 0; i < 1000000; i++)
        {
            GameObject.FindGameObjectWithTag("SomePepper");
        }
	}

Vector3.RotateTowards (200 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.RotateTowards(v1, v2, 0.235F, 0.356F);
        }
	}

Physics.OverlapSphereNonAlloc (200 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);

        Collider[] result = new Collider[4];

        for (int i = 0; i < 1000000; i++)
        {
            Physics.OverlapSphereNonAlloc(v1, 0.235F, result);
        }
	}

Physics.CheckSphere (180 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        for (int i = 0; i < 1000000; i++)
        {
            Physics.CheckSphere(v1, 0.235F);
        }
	}

Vector3.Slerp / Vector3.SlerpUnclamped (180 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Slerp(v1, v2, 0.235F);
        }
	}

Vector3.Normalize (150 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Normalize(v1);
        }
	}

Vector3.Reflect (140 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Reflect(v1, v2);
        }
	}

Vector3.Max / Vector3.Min (130 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Max(v1, v2);
        }
	}

Vector3.Distance (90 ms)

	void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);


        for(int i = 0; i < 10000000; i++)
        {
            Vector3.Distance(v1, v2);
        }
	}

Vector3.Lerp (90 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Lerp(v1, v2, 0.235F);
        }
	}

Vector3.Cross (60 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Cross(v1, v2);
        }
	}

Vector3.Scale (50 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Scale(v1, v2);
        }
	}

Vector3.Dot (40 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);
        Vector3 v2 = new Vector3(987, 654, 321);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.Dot(v1, v2);
        }
	}

Vector3.SqrMagnitude (30 ms)

    void Update ()
    {      
        Vector3 v1 = new Vector3(123, 456, 789);

        for (int i = 0; i < 1000000; i++)
        {
            Vector3.SqrMagnitude(v1);
        }
	}

------------------------------------------------------------------------------------------------------------------------------------------------------

WICHTIG!: Die CPU-Zeiten gelten ausschließlich für meine Testbedingungen. Die Angaben dienen nur als Vergleich (und sind nicht auf 10ms genau zu nehmen) damit (vor allem Anfänger) Performanceprobleme schneller finden und beheben können.

Ich werde diese Liste noch erweitern wenn ich die Zeit dazu finde

Rangliste 24.05.2017.xlsx

Sneyke · 24. Mai 2017

Coole Sache. Was vielleicht interessant wäre, wäre noch der vergleich zu z.B. einfach 1000000 Additionen auf deinem System. Weil ich weis jetzt nicht ob 150ms für Normalize viel sind oder nicht. Ist ja eigentlich ein nur durch seine länge teilen.

Brodi · 24. Mai 2017

Danke für deinen Beitrag. Ist interessant das einmal so veranschaulicht zu haben, ausserdem haben wir fast die gleiche PC-Austattung.

PS: Du hast zweimal den Test GameObject.FindGameObjectsWithTag und im Script gibt es keinen Unterschied, aber warum braucht das eine fast Doppelt so lang?

GameObject.FindGameObjectsWithTag (540 ms) bei einer Szene mit 200 GameObjects

GameObject.FindGameObjectWithTag (200 ms) bei einer Szene mit 200 GameObects

Sascha · 24. Mai 2017

Schau nochmal genau hin - das eine hat ein s mehr und sucht alle GOs mit dem gegebenen Tag raus, nicht nur eines.

Helishcoffe · 24. Mai 2017

Ja da hast du wie Sascha schon sagte wohl das s nicht gesehen

Werde heute Abend noch ein paar neue Funktionen reinmachen. Mal schauen

Zer0Cool · 24. Mai 2017

Ja coole Sache. Vielleicht die 1 vs 200 untereinander schreiben und was nice wäre wäre eine nette Excel-Tabelle mit Farben und einer Legende
Excel hat so eine Diagrammfunktion wo du die Werte in eine Tabelle schüttest und dann ein beliebiges Diagramm daraus erzeugen kannst (zum Beispiel Balkendiagramm)

Helishcoffe · 24. Mai 2017

vor 1 Minute schrieb Zer0Cool:

Ja coole Sache. Vielleicht die 1 vs 200 untereinander schreiben und was nice wäre wäre eine nette Excel-Tabelle mit Farben und einer Legende
Excel hat so eine Diagrammfunktion wo du die Werte in eine Tabelle schüttest und dann ein beliebiges Diagramm daraus erzeugen kannst.

Okay daran habe ich noch gar nicht gedacht. Werde ich mal in Erwägung ziehen wenn ich noch mehr Funktionen gesammelt habe

Brodi · 24. Mai 2017

vor 6 Stunden schrieb Sascha:

Schau nochmal genau hin - das eine hat ein s mehr und sucht alle GOs mit dem gegebenen Tag raus, nicht nur eines.

Upsala voll übersehen

Helishcoffe · 24. Mai 2017

Link zur Excel-Tabelle ist nun oben im drinne

Zer0Cool · 24. Mai 2017

Zeig es oben am besten als Grafik an, ich habe mittlerweile echt bedenken eine Excel- oder Worddatei anzuklicken, der Verschlüsselungstrojaner geht um und der verwendet eine Exceldatei + Makro.

GoldBaercheN · 27. Mai 2017

n1

Anmelden

Performance-Rangliste einiger Funktionen

Recommended Posts

Helishcoffe

Link zu diesem Kommentar

Auf anderen Seiten teilen

Sneyke

Link zu diesem Kommentar

Auf anderen Seiten teilen

Brodi

Link zu diesem Kommentar

Auf anderen Seiten teilen

Sascha

Link zu diesem Kommentar

Auf anderen Seiten teilen

Helishcoffe

Link zu diesem Kommentar

Auf anderen Seiten teilen

Zer0Cool

Link zu diesem Kommentar

Auf anderen Seiten teilen

Helishcoffe

Link zu diesem Kommentar

Auf anderen Seiten teilen

Brodi

Link zu diesem Kommentar

Auf anderen Seiten teilen

Helishcoffe

Link zu diesem Kommentar

Auf anderen Seiten teilen

Zer0Cool

Link zu diesem Kommentar

Auf anderen Seiten teilen

GoldBaercheN

Link zu diesem Kommentar

Auf anderen Seiten teilen

Join the conversation

Umsehen

Aktivitäten