Автор Тема: Тесты производительности  (Прочитано 805 раз)

0 Пользователей и 1 Гость просматривают эту тему.

Ноябрь 30, 2014, 06:20:33 am
Прочитано 805 раз

Mimi Neko

  • Администратор
  • Старожил форума

  • Оффлайн
  • *****

  • 2454
  • Репутация:
    153
    • Просмотр профиля

Попались тут мне тесты одного форумчанина с ником bwolf88, с одного форума.
Тесты интересные, темболее что я как-то давно уже, сам похожие тесты делал (нужно будет выложить)

Итак, цитирую сам пост:

Цитировать
Провел небольшие сравнительные тесты расчетов некоторых типов данных, а также скорость доступа к массивам. Тесты проводились путем зажатия кнопки в Update и использования обычной статистики unity .


//assTest--------------
     int iA;
     int iB = 12;

     //arrayTest-----------------
     int[,] arr1 = new int[2,2]{{1,4},{2,7}};
     int[] arr2 = new int[4] {1, 4, 2, 7};
     object[] arr3 = new object[4] { 1, "a", new Vector3(1, 1, 0), 5 };
     int arB;

     //Vector3 test
     Vector3[] arr4 = new Vector3[] { new Vector3(0, 1, 1), new Vector3 ( -1, 0, 0 ), new Vector3 ( 2, 0, 0 ) };
     Vector3 vAr1;
     Vector3 vAr2 = new Vector3(1, 0, 0);
     Vector3 vAr3 = new Vector3(2, 4, 5);
     float vx, vy, vz;

     void Update()
     {
         ControlTest();
     }

     void testExample()
     {
         Stopwatch st = new Stopwatch(); TimeSpan ts; st.Start();

         st.Stop(); ts = st.Elapsed; print(ts);
     }

     #region AssignedTest

     void AssT1()
     {
         for (int i = 0; i < 10000000; i++)
         {
             iA = 12;
         }
         //48ms
     }

     void AssT2()
     {
         for (int i = 0; i < 10000000; i++)
         {
             iA = iB;
         }
         //53ms
     }

     void AssT3()
     {
         for (int i = 0; i < 10000000; i++)
         {
             iA = AssT4();
         }
         //130ms
     }

     int AssT4()
     {
         return 12;
     }

     #endregion

     #region ArrayTest

     void ArrT1()
     {
         for (int i = 0; i < 10000000; i++)
         {
             arB = arr1[1, 1];
         }
         //133ms
     }

     void ArrT2()
     {
         for (int i = 0; i < 10000000; i++)
         {
             arB = arr2[2];
         }
         //51ms
     }

     void ArrT3() // ----------приемлемый вариант
     {
         for (int i = 0; i < 10000000; i++)
         {
             int ind1 = 2*18;
             arB = arr2[1 + 1];
         }
         //64ms
     }

     void ArrT4()
     {
         for (int i = 0; i < 10000000; i++)
         {
             arB = (int)arr3[0];
         }
         //74ms
     }

     #endregion

     #region Vector3Test
     void VecT1()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = (Vector3)arr4[0];
         }
         //90ms
     }

     void VecT2()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = Vector3.right;
         }

         //295ms
     }
     void VecT3()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = new Vector3(1, 0, 2);
         }

         //220ms
     }

     void VecT4()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = vAr2;
         }
         //72ms
     }

     void VecT5()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vx = vAr2.x+12.1f;
             vy = vAr2.y+13.2f;
             vz = vAr2.z+14.5f;
             vAr1.x = vx;
             vAr1.y = vy;
             vAr1.z = vz;
         }
         //173ms
     }

     void VecT6() //приемлемый
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1.x = vAr2.x + 12.1f;
             vAr1.y = vAr2.y + 13.2f;
             vAr1.z = vAr2.z + 14.5f;
         }
         //101ms
     }

     void VecT7()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1.x = vAr2.x + vAr3.x;
             vAr1.y = vAr2.y + vAr3.y;
             vAr1.z = vAr2.z + vAr3.z;
         }
         //119ms
     }

     void VecT8()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = vAr2 + new Vector3(1, 5, 4);
         }
         //510ms
     }

     void VecT9()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = vAr2 + vAr3;
         }
         //388ms
     }

     void VecT10()
     {
         for (int i = 0; i < 10000000; i++)
         {
             vAr1 = vAr2 + Vector3.right;
         }
         //610ms
     }

     #endregion

     void ControlTest()
     {
         if (Input.GetMouseButton(0))
         {
             VecT10();
         }   
         if (Input.GetMouseButton(1))
         {
             VecT8();
         }
         if (Input.GetKey(KeyCode.LeftControl))
         {
             VecT3();
         }
         if (Input.GetKey(KeyCode.LeftShift))
         {
             VecT4();
         }
     }

 

Цитировать
Что можно увидеть:
1. Одномерный массив с множителем почти в 2 раза быстрее любого многомерного массива.
2. Готовые конструкции типа Vector3.zero, Vector3.up на порядок медленнее заготовленных векторов и немного медленее new Vector(x,y,z) (только что созданных векторов)
3. Складывать, вычитать векторы в 3,5 раза медленее (готовые), в 5 раз медленее (если есть только что созданный вектор), и в 6 раз медленнее (если Vector3.up/right и т.п.), чем проводить те же операции с их индексами.
4. Получение значения используя другой метод того же типа, что и переменная в 2 раза медленее чем получать значение, вычисляя его в самом методе.
5. На счет того, что списки в 2 раза медленнее массивов, думаю говорить не нужно .

Если у кого есть подобные тесты производительности или уже готовые решения повышающие скорость вычислений - прошу не стесняться выкладывать, мне очень нужна подобная информация.

bwolf88.