STL 向量上的重复操作是否允许"Inherent Parallelism"/改进的内存访问？

我有一个两阶段的过程，在我的模拟程序中构成了一个循环。 我或多或少有以下几点：

struct Coordinates
{
   double * x, * y, * z;
   uint * kind, count;
   double GetDist(const uint p1, const uint p2);
};
struct Polynomial
{
   double * A, * B;
   uint n1, n2;
   uint Flatten(const uint i, const uint j);
   double CalcResult(double distSq, uint kind1, uint kind2)
   {
      uint ij = Flatten(kind1, kind2);
      double base = B * distSq;
      return A[ij]*(pow(base,n2)-pow(base,n1));
   }
};

我的问题是我是否像这样编写代码

struct Model
{
   Coordinates c;
   Polynomial f;
   double DoTest()
   {
      double result = 0;
      uint count = 0;
      std::vector<double> distSq;
      for (uint i=0; i<c.count; i++)
      {
         for (uint j=i; j<c.count; j++)
         {
            result = c.GetDist(i,j);
            distSq.push_back(result);
         }
      }
      result = 0;
      for (uint i=0; i<c.count; i++)
      {
         for (uint j=i; j<c.count; j++)
         {
            result += f.CalcResult(distSq[count], i, j);
            count++;
         }
      }
      return result;
   }
   double DoTest2()
   {
      double result = 0;
      for (uint i=0; i<c.count; i++)
         for (uint j=i; j<c.count; j++)
            result += f.CalcResult(c.GetDist(i,j), i, j);
      return result;
   }
}

鉴于 x86 芯片上的重复操作，Test是否会在 x86 芯片上自动启用并行性（例如矢量化数学或改进的内存访问）？

否则Test是一种垃圾方法——它使用额外的存储空间（std::vector<double> distSq;），并且在代码读取方面要长得多。 从逻辑上讲，它或多或少是相同的，但是如果我们调用GetDist f_A（函数 A）和CalcResult f_B（函数 B），则 Test 是：

f_A f_A f_A ... f_A    f_B f_B .... f_B

其中，较短/较少的内存密集型函数为

f_A f_B f_A f_B .... f_A f_B

我听说过由于生成的矢量化数学运算等，在编译-O# C 代码中谈论所谓的"固有并行性"。 鉴于x86芯片上的重复操作，Test能否在x86芯片上启用这种编译器派生的并行性（例如矢量化数学或优化的内存访问？

（否则Test2是唯一合理的方法，因为它使用较少的内存。

另外，用std::vector<double>的替代方案替换c风格的x、y和z数组是否有可能以任何方式加速计算或内存访问？

请不要回答"对自己进行基准测试"...我要求尝试更好地理解是否值得从理论角度测试方法Test，基于编译器和"固有并行性"。