错误、漏洞、问题 - 页 2878

新评论
 
Igor Makanu:

在优化过程中，哪种转换方式会更快地发挥作用

这将只在每次传递中被调用一次。因此，这没有什么区别。

 
fxsaber:

对整个段落来说，这只会被调用一次。所以这没有什么区别。

所以是的...但我要运行几天进行优化，我想以某种方式衡量性能，.....，虽然我怀疑变体1会更有效率，但不会有100500次的复制到数组中的情况出现

 
Igor Makanu:

是的...但是我打算让电脑运行几天来进行优化，我想通过某种方式来衡量性能，.....，虽然我怀疑方案1会更有效率，但不会有100500次的复制到数组的情况出现

所以变体2很可能更快，但正如你上面指出的，这并不重要。
 
TheXpert:
union不是复制到数组，而是对同一内存空间的不同解释。因此，第二种方案可能更快，但如上所述，这并不重要。
联盟并不像它看起来那么快。不幸的是。
我把赌注压在第一个人身上。
 
Igor Makanu:

是的...但是我打算让电脑运行几天来进行优化，我想通过某种方式来衡量性能，.....，尽管我怀疑方案1会更有效率，不会有100500次的复制到数组的情况出现

有一个古老的方法来衡量速度

风格的

for (int i=0; i< 1000000; i++) {我们的代码1}
for (int i=0; i< 1000000; i++) {我们的代码2}....

 
Nikolai Semko:
联盟并不像它听起来那么快。我把赌注押在了第一个项目上。

我也赌第一种！二进制运算符比if运算符快几倍，虽然第二种没有。

 

检查了。

#define    SpeedTest(count_x10,msg,EX)        {ulong mss=GetMicrosecondCount(); ulong count=(ulong)pow(10,count_x10);for(ulong _i=0;_i<count&&!_StopFlag;_i++){EX;} \
                                              printf("%s: loops=%llu ms=%llu",msg,count,GetMicrosecondCount()-mss);}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   ulong sum = 0;
   SpeedTest(10, "tst 1 : ",
   {
      ushort in01A = (ushort)rand();
      ushort in01B = (ushort)rand();
      ushort in02A = (ushort)rand();
      ushort in02B = (ushort)rand();
      ushort in03A = (ushort)rand();
      ushort in03B = (ushort)rand();
      ushort in04A = (ushort)rand();
      ushort in04B = (ushort)rand();
      ushort in05A = (ushort)rand();
      ushort in05B = (ushort)rand();
      uint param[5];
      param[0] = (uint)in01A << (sizeof(ushort) * 8) | in01B;
      param[1] = (uint)in02A << (sizeof(ushort) * 8) | in02B;
      param[2] = (uint)in03A << (sizeof(ushort) * 8) | in03B;
      param[3] = (uint)in04A << (sizeof(ushort) * 8) | in04B;
      param[4] = (uint)in05A << (sizeof(ushort) * 8) | in05B;
      for(int i = 0; i < 5; i++) sum += param[i];
   });
//--   
   sum = 0;
   union ushortTouint
   {
      uint param[5];
      ushort in[10];
   }U;
   SpeedTest(10, "tst 2 : ",
   {
      ushort in00 = (ushort)rand();
      ushort in01 = (ushort)rand();
      ushort in02 = (ushort)rand();
      ushort in03 = (ushort)rand();
      ushort in04 = (ushort)rand();
      ushort in05 = (ushort)rand();
      ushort in06 = (ushort)rand();
      ushort in07 = (ushort)rand();
      ushort in08 = (ushort)rand();
      ushort in09 = (ushort)rand();
      ushortTouint u;
      u.in[0] = in00;
      u.in[1] = in01;
      u.in[2] = in02;
      u.in[3] = in03;
      u.in[4] = in04;
      u.in[5] = in05;
      u.in[6] = in06;
      u.in[7] = in07;
      u.in[8] = in08;
      u.in[9] = in09;
      for(int i = 0; i < 5; i++) sum += u.param[i];
   });

}

2020.10.15 21:48:01.401 SpeedTst (EURUSD,H1) tst 1 : : loops=10000000000 ms=10864370

2020.10.15 21:48:12.264 SpeedTst (EURUSD,H1) tst 2 : : loops=10000000000 ms=10862287

差异并不显著，如果我们把测试的顺序换成相反的，结果很可能会相反。

不重要

 
Igor Makanu:

差异不大，如果你交换测试，结果很可能是相反的。

在这种情况下，只需选择你主观上更喜欢的那一种。

 
Igor Makanu:

检查了。

2020.10.15 21:48:01.401 SpeedTst (EURUSD,H1) tst 1 : : loops=10000000000 ms=10864370

2020.10.15 21:48:12.264 SpeedTst (EURUSD,H1) tst 2 : : loops=10000000000 ms=10862287

差异并不显著，如果我们以相反的顺序进行测试，结果很可能会相反。

不重要

这里的脚本演示了随机数创建的时间可能是不均匀的，并且取决于创建变量的数量)))

而我们在这个重复次数中所需要的代码需要我0毫秒。

仍然没有回答。

或者是代码优化器剪掉了一些不必要的东西
 
Alexandr Andreev:

似乎有一个脚本证明了随机数生成的时间可以是不平等的

没有rand()是一个正常的函数，它的工作原理总是一样的。

但在测试速度时，如果你用常量初始化它，测试将在执行过程中 "加速"--MQL在 运行期间的代码优化是好的

一般来说，它被检查过很多次

Alexandr Andreev:

而且很多时候取决于创建的变量的大小））））。

当然，分配内存是很耗时的，我检查过了，我同时测试了动态创建的对象（新指针）和本地范围 内的对象，测试中每次新建+删除的次数达到了100500次。

整个问题是，因为在测试器中，全局范围的内存是一次性分配给变量的，而不是每次都分配 - 但我需要uint数组，所以我用这个脚本测试，而不是像我第一次写的那样

Alexandr Andreev:

而我们在这个重复次数中需要的代码需要我花0毫秒的时间

仍然没有答复

要么是代码优化器在削减一些不必要的东西。

你用了我的脚本吗？- 要么你没有等到测试结束就中断了，要么你溢出了ulong - 第一个宏参数是10^数



Andrei Trukhanovich:

在这种情况下，只需选择你主观上最喜欢的那个。

是的，也许是这样

这正是我想问的--我读过很多次，现代处理器通过优化指令流水线可以在每个时钟内执行一个以上的基本操作....。一大堆胡说八道...而问题是，算术指令被处理器在不可预测的时钟周期内执行。

至于分支和内存分配操作，它们被处理器优化得非常糟糕，所以不要在简化算术中寻找优化，尽量写出具有最小分支的最大线性代码，变量最好在计算前就声明和赋值，这样可以让指令流水线和高速缓存采样预测来优化这段代码。


也就是说，对数组中元素的取样值（寻址）很可能对速度并不重要--我以为会有一个移位优势与联合优势，结果是根本没有区别。

1...287128722873287428752876287728782879288028812882288328842885...3184
新评论