Errori, bug, domande - pagina 2507

Nuovo commento
 
Vict:

Ho risolto l'idea originale (il primo codice non contava correttamente gli indirizzi). Se non ti dispiace, sarà interessante vedere il risultato con te.

C'è una grande variazione da corsa a corsa, non riesco a vedere la differenza in una direzione o nell'altra. Naturalmente, sto eseguendo la versione 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:
Un array dinamico ha più controlli, Renat una volta ha scritto, non riesco a trovare il post, parlando solo dell'accesso all'indice, perché è significativamente più lento di plus

Si scopre che quando si riempiono gli array dinamici, è meglio riempire prima gli array statici, e poi fare ArrayCopy sugli array dinamici.

 
fxsaber:
Cosa causa questo rallentamento?

Avete fatto un array dinamico da uno statico. Da qui tutti i problemi di tipo che ne derivano:

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]++;
        }
}

Quando il primo e il secondo ciclo corrono a velocità diverse.

 
fxsaber:

Grazie. È strano, naturalmente. Ho una differenza stabile.

 
Vict:

Grazie. È strano, naturalmente. Ho una differenza stabile.

Nemmeno io ho una differenza.
 
fxsaber:

Si è scoperto che quando si riempiono gli array dinamici, è meglio riempire prima gli array statici, e poi fare ArrayCopy sugli array dinamici.

Così è!

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));
}
 
fxsaber:

Lo è!

Beh, l'inizializzazione è di solito una cosa una tantum e il più delle volte non ci si deve preoccupare della velocità. (più l'overhead della memoria)

Ma se c'è un riferimento costante per indici e per esempio nel ~99.9% dei casi la dimensione massima dell'array è nota, probabilmente ha senso scrivere il tuo semplice wrapper intorno all'array statico per sostituire quello dinamico.

 
TheXpert:

Beh, l'inizializzazione è di solito una cosa una tantum e la maggior parte delle volte non ci si deve preoccupare della velocità. (più l'overhead della memoria).

Ho un record che rallenta quando analizza i tick. Ce ne sono decine di milioni, quindi è importante.

Ma se c'è un riferimento costante per indici e per esempio nel ~99.9% dei casi la dimensione massima dell'array è nota, probabilmente ha senso scrivere il vostro semplice wrapper intorno all'array statico invece di quello dinamico.

Potrebbe avere senso fare anche un wrap on read.


SZZ In lettura, non riesco a ottenere alcuna accelerazione.

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)));
}
 
fxsaber:

Lo è!

il mio fillarray1 è leggermente più veloce

e la lettura è un casino.

 
TheXpert:

il mio fillarray1 è leggermente più veloce

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

La versione di rilascio è in esecuzione. Ottimizzazione abilitata.

1...250025012502250325042505250625072508250925102511251225132514...3184
Nuovo commento