Not a question - just some performance metrics for rendering from Unity scripts

I need to dynamically instantiate and alter GameObjects from scripts and wanted to share what I found about the performance of these scripts. I've included the C# source code at the bottom.

Testing protocol: I am running Unity 4.0.1f2. The script below was attached to the Main Camera object, and references a simple prefab Cube called myCube. For the tests below, I took the best of 3 times to try and minimize reflection of any temporary bottlenecks or CPU overload created by other programs running on my mac$$anonymous$$ne (Lenovo G560 running 64-bit Windows 7, 2.13GHz, 4.0GB RAM). Test result is the average seconds per render over 1000 renders.

1000 cubes, static: 0.01022 seconds per render

1000 cubes, floating away along the z-axis (1), using new Vector3: 0.01316 s/render

1000 cubes, floating away along the z-axis (1), using static Vector3.forward: 0.01362 s/render

At t$$anonymous$$s point, I was surprised that multiplying a static vector by the time elapsed generated worse results than instantiating new vectors for each cube on each render, but the order of magnitude of the difference here was lower to a point that I just decided to continue using new Vector3 instantiation for each test below and assume results would be comparable with the static Vector3.

1000 cubes, stretc$$anonymous$$ng along one axis (2): 0.01691 s/render

Benchmarking the cost of generating Random values: 1000 cubes, on each render generating a Random.range value for each cube (but doing not$$anonymous$$ng with it): .01042 s/render

After t$$anonymous$$s, I did not include any further metrics to assess cost of the Random float generator, since the order or magnitude of the difference is again much smaller, and probably comparable in order of magnitude to the variance caused by my admittedly rudimentary testing method.

1000 cubes, enabling/disabling each on each render according to a random value (3): .01928 s/render

1000 cubes, floating away along the z-axis (1) w$$anonymous$$le also stretc$$anonymous$$ng along one axis (2): 0.01809 s/render

1000 cubes, floating away along the z-axis (1) w$$anonymous$$le also enabling/disabling randomly (3): 0.02261 s/render

1000 cubes, stretc$$anonymous$$ng along one axis (2) w$$anonymous$$le also enabling/disabling randomly (3): 0.03292 s/render

1000 cubes, floating away along the z-axis (1), stretc$$anonymous$$ng along one axis (2), and enabling/disabling randomly (3): 0.03404 s/render

Hope t$$anonymous$$s helps!

Source code:

 using UnityEngine;
 using System.Collections;
 
 public class makeCube : MonoBehaviour {
     
     public static int num_shapes=1000;
     
     public GameObject myCube;
     
     float lastRenderTime;
     Vector3[] v3array;
     GameObject[] oarray;
     
     int renders;
     float totalRenderingTime;
     
     void Start () {
         renders=0;
         totalRenderingTime=0.0F;
         
         lastRenderTime = Time.time;
         
         v3array = new Vector3[num_shapes];
         oarray = new GameObject[v3array.Length];
         for (int i=0; i<v3array.Length; i++)
         {
             v3array[i] = new Vector3(((float)i)/400.0F,((float)i)/250.0F,((float)i)/500.0F);
         }
         Quaternion q = Quaternion.identity;
 
         for(int i=0; i<v3array.Length; i++)
          {
             oarray[i] = (GameObject)Instantiate(myCube, v3array[i], q);
         }
     }
     
     void Update () {
     
         renders++;
         totalRenderingTime+=(Time.time-lastRenderTime);
         if (renders%100==0)
             print (renders + " renders in " + totalRenderingTime + " seconds");
         
         float enableRandom=0;
         
         for(int i=0; i<v3array.Length; i++)
         {
             // TRANSFORM 1: Floating away along the z-axis
             //oarray[i].transform.position += Vector3.forward * (Time.time-lastRenderTime);
             //oarray[i].transform.position += new Vector3(0.0F,0.0F,(Time.time-lastRenderTime));
             
             //TRANSFORM 2: Stretc$$anonymous$$ng along one axis
             //oarray[i].transform.localScale += new Vector3((Time.time-lastRenderTime),0.0F,0.0F);
             
             //TRANSFORM 3: Enabling/disabling randomly
             /*enableRandom = Random.Range(-1.0F, 1.0F);
             if (enableRandom > 0)
             {
                 oarray[i].SetActive(true);
             }
             else
             {
                 oarray[i].SetActive(false);
             }*/
         }
         lastRenderTime = Time.time;
     }
 }