Ошибки, баги, вопросы - страница 2507

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

Довёл до ума первоначальную идею (в первом коде неправильно считал адреса). Если не затруднит, то интересно будет посмотреть на результат у вас.

Разброс сильный от запуска к запуску, разницы постоянной в чью-то сторону не видно. Конечно, запускаю Release-вариант.

#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);
}
 
TheXpert:
у динамического массива больше проверок, Ренат как-то писал, пост не найду, как раз в разговоре об обращении по индексу, почему существенно медленней плюсов

Получается, что при заполнении динамических массивов лучше сначала заполнять статические, а потом делать ArrayCopy в динамические.

 
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:

Спасибо. Странно, конечно. У меня стабильная разница.

 
Vict:

Спасибо. Странно, конечно. У меня стабильная разница.

У меня тоже разницы нет.
 
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, 1e7);

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

Так и есть!

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

а вот если идет постоянное обращение по индексам и допустим в ~99.9% случаев известен максимальный размер массива, возможно есть смысл написать свою простую обертку вокруг статического массива на замену динамическому.

 
TheXpert:

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

У меня запись тормозит при парсинге тиков. Там их десятки миллионов, поэтому значение имеет.

а вот если идет постоянное обращение по индексам и допустим в ~99.9% случаев известен максимальный размер массива, возможно есть смысл написать свою простую обертку вокруг статического массива на замену динамическому.

Возможно, что и при чтении имеет смысл делать обертку.


ЗЫ На чтении не получилось ускориться

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, 1e8);
  ArrayInitialize(Array, 1);
      
  BENCH(Print(ArraySum1(Array)));
  BENCH(Print(ArraySum2(Array)));
}
 
fxsaber:

Так и есть!

у меня fillarray1 чуть быстрее

а с чтением там совсем беда

 
TheXpert:

у меня fillarray1 чуть быстрее

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

Release-версию запускаю. Оптимизация включена.

1...250025012502250325042505250625072508250925102511251225132514...3521
Новый комментарий
Причина обращения: