为什么numpy的效率无法扩展

我一直在比较numpy与Python列表推导将随机数数组相乘的相对效率。（Python 3.4 / Spyder，Windows和Ubuntu）。

正如人们所期望的那样，对于除最小数组以外的所有数组，numpy的性能迅速超过了列表理解，并且随着数组长度的增加，您可以获得预期的S形曲线。但是乙状结肠远非光滑，我对此感到困惑。

显然，对于较短的阵列长度，存在一定数量的量化噪声，但是我得到的噪声却出乎意料，尤其是在Windows下。这些数字是各种阵列长度的100次运行的平均值，因此应消除任何瞬时影响（所以我会想到）。

Numpy and Python list performance comparison

下图显示了使用numpy与列表推导的长度不同的数组相乘的比率。

Array Length    Windows     Ubuntu
           1        0.2        0.4
           2        2.0        0.6
           5        1.0        0.5
          10        3.0        1.0
          20        0.3        0.8
          50        3.5        1.9
         100        3.5        1.9
         200       10.0        3.0
         500        4.6        6.0
       1,000       13.6        6.9
       2,000        9.2        8.2
       5,000       14.6       10.4
      10,000       12.1       11.1
      20,000       12.9       11.6
      50,000       13.4       11.4
     100,000       13.4       12.0
     200,000       12.8       12.4
     500,000       13.0       12.3
   1,000,000       13.3       12.4
   2,000,000       13.6       12.0
   5,000,000       13.6       11.9

所以我想我的问题是，谁能解释为什么结果，尤其是在Windows下如此嘈杂。我已经多次运行测试，但结果似乎总是完全相同。

更新。在Reblochon Masque的建议下，我已禁用了抓斗收集。这可以使Windows的性能稍微有些平滑，但是曲线仍然很粗糙。

Numpy and Python list performance comparison
(Updated to remove garbage collection)

Array Length    Windows     Ubuntu
           1        0.1        0.3
           2        0.6        0.4
           5        0.3        0.4
          10        0.5        0.5
          20        0.6        0.5
          50        0.8        0.7
         100        1.6        1.1
         200        1.3        1.7
         500        3.7        3.2
       1,000        3.9        4.8
       2,000        6.5        6.6
       5,000       11.5        9.2
      10,000       10.8       10.7
      20,000       12.1       11.4
      50,000       13.3       12.4
     100,000       13.5       12.6
     200,000       12.8       12.6
     500,000       12.9       12.3
   1,000,000       13.3       12.3
   2,000,000       13.6       12.0
   5,000,000       13.6       11.8

更新

在@Sid的建议下，我将其限制为只能在每台计算机的单个内核上运行。曲线稍微更平滑（尤其是Linux曲线），但是仍然带有弯曲和一些噪音，尤其是在Windows下。

（实际上，这是我最初要发布的变形，因为它们始终出现在相同的位置。）

Numpy and Python list performance comparison
(Garbage collection disabled and running on 1 CPU)

Array Length    Windows     Ubuntu
           1        0.3        0.3
           2        0.0        0.4
           5        0.5        0.4
          10        0.6        0.5
          20        0.3        0.5
          50        0.9        0.7
         100        1.0        1.1
         200        2.8        1.7
         500        3.7        3.3
       1,000        3.3        4.7
       2,000        6.5        6.7
       5,000       11.0        9.6
      10,000       11.0       11.1
      20,000       12.7       11.8
      50,000       12.9       12.8
     100,000       14.3       13.0
     200,000       12.6       13.1
     500,000       12.6       12.6
   1,000,000       13.0       12.6
   2,000,000       13.4       12.4
   5,000,000       13.6       12.2