5 Знаков - страница 2

Новый комментарий
 
Dina Paches:

Не вижу смысла с вами спорить. Ну только вот к этому пояснение напишу:

Но не располагаю информацией, позволяющей мне быть уверенной в репрессиях, или предполагать о них, по отношению к обсуждаемым функциям Проверки состояния (а домыслами не люблю заниматься).

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

Спор об эффективности решается как-то так:

#property strict

void OnStart()
{
   long startTickCnt = GetTickCount();
   for(int i = 0; i < 100000000; i++)
   {
      double point = _Point;
   }
   
   Alert("_Point: ", GetTickCount() - startTickCnt);
   
   long startTickCnt2 = GetTickCount();
   for(int i = 0; i < 100000000; i++)
   {
      double point = Point();
   }
   
   Alert("Point(): ", GetTickCount() - startTickCnt2);
}

У меня выдало несколько результатов:

_Point: 234, Point(): 234

_Point: 234, Point(): 234

_Point: 250, Point(): 249

_Point: 249, Point(): 234

_Point: 250, Point(): 218

_Point: 281, Point(): 234

_Point: 243, Point(): 265

Не убедился в том, что _Point обязательно быстрее (даже в четырёх случаях из семи оказался медленнее). Или я что-то не так делаю?

 

Вот немного другой скрипт:

#property strict

void OnStart()
{
   long startTickCnt = GetTickCount();
   for(int i = 0; i < 100000000; i++)
   {
      double point = _Point;
   }
   long endTickCnt = GetTickCount();
   
   
   long startTickCnt2 = GetTickCount();
   for(int i = 0; i < 100000000; i++)
   {
      double point = Point();
   }
   long endTickCnt2 = GetTickCount();
   
   string str1 = "_Point: " + (string)(endTickCnt - startTickCnt);
   string str2 = "Point(): " + (string)(endTickCnt2 - startTickCnt2);
   Alert(str1," | ", str2);
}

Результаты у меня:

_Point: 234 | Point(): 234
_Point: 234 | Point(): 234
_Point: 234 | Point(): 219
_Point: 280 | Point(): 234
_Point: 234 | Point(): 234
_Point: 219 | Point(): 249
_Point: 234 | Point(): 234

В этот раз один результат из семи показал, что _Point быстрее, и два раза из семи, что Point() быстрее (выделил жирным). В четырёх других случаях результат оказался идентичным. Пока тоже не очень убедительно.

 
Sergey Eremin:

Спор об эффективности решается как-то так

Попробуйте поменять местами _Point и Point() в циклах. А лучше - поставьте Point() в оба цикла
 

...и вот ещё другой скрипт (делает 50 замеров и подсчитывает результаты):

#property strict

void OnStart()
{
   Alert("-------");
   string text = "";
   int equalCnt = 0;
   int fasterCnt = 0;
   int slowerCnt = 0;
   for(int j = 0; j < 50; j++)
   {
      long startTickCnt = GetTickCount();
      for(int i = 0; i < 100000000; i++)
      {
         double point = _Point;
      }
      long endTickCnt = GetTickCount();
      
      
      long startTickCnt2 = GetTickCount();
      for(int i = 0; i < 100000000; i++)
      {
         double point = Point();
      }
      long endTickCnt2 = GetTickCount();
      
      long v1 = endTickCnt - startTickCnt;
      long v2 = endTickCnt2 - startTickCnt2;
      if(v1 == v2)
      {
         equalCnt++;
      }
      else if(v1 < v2)
      {
         fasterCnt++;
      }
      else if(v1 > v2)
      {
         slowerCnt++;
      }      
      
      string str1 = "_Point: " + (string)v1;
      string str2 = "Point(): " + (string)v2;
      
      text = text + (string)j + ")" + str1 + " | " + str2 + "\r\n";
   }
   
   string equalCntStr = "_Point равно Point() " + (string)equalCnt + " раз";
   string fasterCntStr = "_Point быстрее Point() " + (string)fasterCnt + " раз";
   string slowerCntStr = "_Point медленнее Point() " + (string)slowerCnt + " раз";
   
   Alert(text, "\r\n\r\n", equalCntStr,"\r\n",fasterCntStr,"\r\n",slowerCntStr);
}

У меня результат такой:

0)_Point: 218 | Point(): 250
1)_Point: 234 | Point(): 234
2)_Point: 234 | Point(): 234
3)_Point: 234 | Point(): 249
4)_Point: 219 | Point(): 234
5)_Point: 234 | Point(): 234
6)_Point: 234 | Point(): 234
7)_Point: 249 | Point(): 265
8)_Point: 234 | Point(): 234
9)_Point: 234 | Point(): 250
10)_Point: 218 | Point(): 234
11)_Point: 219 | Point(): 249
12)_Point: 219 | Point(): 234
13)_Point: 234 | Point(): 249
14)_Point: 250 | Point(): 234
15)_Point: 234 | Point(): 250
16)_Point: 218 | Point(): 234
17)_Point: 218 | Point(): 250
18)_Point: 234 | Point(): 234
19)_Point: 218 | Point(): 250
20)_Point: 265 | Point(): 250
21)_Point: 218 | Point(): 250
22)_Point: 234 | Point(): 249
23)_Point: 219 | Point(): 234
24)_Point: 234 | Point(): 234
25)_Point: 234 | Point(): 234
26)_Point: 218 | Point(): 250
27)_Point: 218 | Point(): 234
28)_Point: 234 | Point(): 265
29)_Point: 219 | Point(): 249
30)_Point: 219 | Point(): 249
31)_Point: 219 | Point(): 234
32)_Point: 234 | Point(): 281
33)_Point: 234 | Point(): 249
34)_Point: 219 | Point(): 249
35)_Point: 219 | Point(): 234
36)_Point: 218 | Point(): 250
37)_Point: 218 | Point(): 250
38)_Point: 234 | Point(): 234
39)_Point: 405 | Point(): 250
40)_Point: 234 | Point(): 265
41)_Point: 234 | Point(): 234
42)_Point: 219 | Point(): 249
43)_Point: 219 | Point(): 234
44)_Point: 234 | Point(): 234
45)_Point: 249 | Point(): 281
46)_Point: 218 | Point(): 250
47)_Point: 218 | Point(): 234
48)_Point: 234 | Point(): 234
49)_Point: 219 | Point(): 249


_Point равно Point() 12 раз
_Point быстрее Point() 35 раз
_Point медленнее Point() 3 раз

Теперь уже более убедительно.

 
Alexander Puzanov:
Попробуйте поменять местами _Point и Point() в циклах. А лучше - поставьте Point() в оба цикла

Да, Вы правы. Поставил в обоих Point() и таки результаты не совпали в 23 случаях из 50 примерно на 15-20 ms. Но распределение более равномерное: 13 раз больше и 10 раз меньше, а не как в предыдущем сообщении: 35 и 3.

Может кто-нибудь предложить более точный способ замера?

И да, я понимаю насколько ничтожны различия, но хочется истины (если конечно она не сводится к тому, что все Point() меняются на _Point во время компиляции).

 
Sergey Eremin:

(если конечно она не сводится к тому, что все Point() меняются на _Point во время компиляции).

Скорей всего
 
Alexander Puzanov:
Скорей всего

Да, похоже все мои замеры на грани погрешности. Я увидел результат, когда скрипт показал, что _Point медленнее чем Point() в 40 случаях из 50. Но почти все отличия упираются в те же 15-20 мс (на 100000000 итераций!). Увеличение количества итераций циклов на два порядка помимо неплохого прогрева комнаты до некомфротных температур дают тот же результат: "раз на раз не приходится".

Думаю, особой разницы по производительности между ними всё таки нет. Остаётся только религия (личные предпочтения и вера, включая веру в те или иные репрессии).

 
Точность замеров GetTickCount примерно 16 мс. Поэтому все замеры помещаются в зону погрешности. 
 
Sergey Eremin:

Да, похоже все мои замеры на грани погрешности. Я увидел результат, когда скрипт показал, что _Point медленнее чем Point() в 40 случаях из 50. Но почти все отличия упираются в те же 15-20 мс (на 100000000 итераций!). Увеличение количества итераций циклов на два порядка помимо неплохого прогрева комнаты до некомфротных температур дают тот же результат: "раз на раз не приходится".

Думаю, особой разницы по производительности между ними всё таки нет. Остаётся только религия (личные предпочтения и вера, включая веру в те или иные репрессии).

Проверьте и просто Point без скобок и подчёркивания впереди! Тут явно видна экономия на лишних знаках!
123456
Новый комментарий
Причина обращения: