错误、漏洞、问题 - 页 2507

[fxsaber]

Vict:

我已经解决了原来的想法（第一个代码没有正确计算地址）。如果你不介意的话，和你一起看看结果会很有趣。

它在不同的运行中变化很大，你无法分辨出一边和另一边的区别。当然，我运行的是发行版。

#define  WRONG_ALIGNED
#define  CACHE_LINE_SIZE 64

struct Data {
#ifdef  WRONG_ALIGNED
   ushort pad;
#else
   uint pad;
#endif
   uint ar[CACHE_LINE_SIZE/sizeof(int)+1];
};

#import "msvcrt.dll"
  long memcpy(uint &, uint &, long);
#import
#define  getaddr(x) memcpy(x, x, 0)

void OnStart()
{
//   Data data[32768];
   Data data[];
  
   ArrayResize(data, 32768); // для не static-массива жуткие тормоза выходят. 
   ZeroMemory(data);
   
   ulong start_time = GetMicrosecondCount();
   
   for(unsigned i = 0; i < 10000; ++ i) {
    for (int j = ArraySize(data) - 1; j >= 0; j--)
    {
         int index = int(CACHE_LINE_SIZE - getaddr(data[j].ar[0]) % CACHE_LINE_SIZE) / sizeof(int);
         ++ data[j].ar[index];
         ++ data[j].pad;
      }
   }
      
   Alert(GetMicrosecondCount() - start_time);
   
//   Print(data[100].ar[0]);
//   Print(data[100].pad);
}

[fxsaber]

TheXpert:
动态数组 有更多的检查，Renat曾经写过，我找不到帖子了，只是说到了索引访问，为什么它明显比正数慢？

事实证明，在填充动态数组时，最好先填充静态数组，然后再做ArrayCopy到动态数组。

[Francuz]

fxsaber:
是什么导致了这种减速？

你把一个静态数组 变成了一个动态数组。因此，所有由此产生的类型问题。

int a[][100];
ArrayResize(a, 100);
ZeroMemory(a);

// Первый цикл
for(int i; i < 100; ++i)
{
        for(int n; n < 100; ++n)
        {
                a[i][n]++;
        }
}

// Второй цикл
for(int n; n < 100; ++n)
{
        for(int i; i < 100; ++i)
        {
                a[i][n]++;
        }
}

当第一和第二环路以不同的速度运行时。

[[删除]]

fxsaber:

谢谢你。当然，这很奇怪。我有一个稳定的差异。

[TheXpert]

Vict:

谢谢你。当然，这很奇怪。我有一个稳定的差异。

我也没有什么不同。

[fxsaber]

fxsaber:

事实证明，在填充动态数组时，最好先填充静态数组，然后再做ArrayCopy到动态数组。

原来是这样!

void FillArray1( int &Array[] )
{
  const int Size = ArraySize(Array);
  
  for (int i = 0; i < Size; i++)
    Array[i] = i;
}

#define  ARRAY_SIZE 10000

void FillArray2( int &Array[] )
{
  int ArrayStatic[ARRAY_SIZE];
  
  const int Size = ArraySize(Array);
  
  for (int i = 0; i < Size;)
  {
    const int Size2 = i + ARRAY_SIZE < Size ? ARRAY_SIZE : Size - i;
    
    for (int j = 0; j < Size2; j++)
      ArrayStatic[j] = i++;
      
    if (Size2)
      ArrayCopy(Array, ArrayStatic, i - Size2, 0, Size2);
  }
}

#define  BENCH(A)                                                               \
{                                                                              \
  const ulong _StartTime = GetMicrosecondCount();                              \
  A;                                                                           \
  Print("Time[" + #A + "] = " + (string)(GetMicrosecondCount() - _StartTime)); \
}

void OnStart()
{
  int Array1[];
  ArrayResize(Array1, 1 e7);

  int Array2[];
  ArrayResize(Array2, 1 e7);
  
  BENCH(FillArray1(Array1));
  BENCH(FillArray2(Array2));
}

[TheXpert]

fxsaber:

它是的!

那么初始化通常是一次性的，大多数时候你不必担心速度问题。(加上内存开销)

但是如果有恒定的索引访问，例如在~99.9%的情况下，最大的数组大小是已知的，那么在静态数组 周围编写自己的简单包装器来替代动态数组可能是有意义的。

[fxsaber]

TheXpert:

那么初始化通常是一次性的，大多数时候你不必担心速度问题。(加上内存开销)。

我有一个记录在解析ticks时变慢了。他们有数千万人，所以这很重要。

但是，如果有恒定的索引引用，并且在~99.9%的情况下，数组的最大尺寸是已知的，那么在静态数组 而不是动态数组 上编写简单的包装器可能是有意义的。

对阅读也做一个包装可能是有意义的。

SZZ 在读取时，我无法得到任何速度的提升。

long ArraySum1( int &Array[] )
{
  long Sum = 0;
  
  const int Size = ArraySize(Array);
  
  for (int i = 0; i < Size; i++)
    Sum += Array[i];
    
  return(Sum);
}

#define  ARRAY_SIZE 100000

long ArraySum2( int &Array[] )
{
  long Sum = 0;

  const int Size = ArraySize(Array);  
  
  int ArrayStatic[ARRAY_SIZE];  
  
  for (int i = 0; i < Size;)
  {
    const int Size2 = i + ARRAY_SIZE < Size ? ARRAY_SIZE : Size - i;

    ArrayCopy(ArrayStatic, Array, 0, i, Size2);
    
    for (int j = 0; j < Size2; j++)
      Sum += ArrayStatic[j];
      
    i += Size2;
  }
  
  return(Sum);
}

#define  BENCH(A)                                                               \
{                                                                              \
  const ulong _StartTime = GetMicrosecondCount();                              \
  A;                                                                           \
  Print("Time[" + #A + "] = " + (string)(GetMicrosecondCount() - _StartTime)); \
}

void OnStart()
{
  int Array[];
  ArrayResize(Array, 1 e8);
  ArrayInitialize(Array, 1);
      
  BENCH(Print(ArraySum1(Array)));
  BENCH(Print(ArraySum2(Array)));
}

[TheXpert]

fxsaber:

它是的!

我的fillarray1稍微快一点

而阅读是一个混乱的过程。

[fxsaber]

TheXpert:

我的fillarray1稍微快一点

Time[FillArray1(Array1)] = 39501
Time[FillArray2(Array2)] = 30304

发行版本正在运行。启用优化功能。