ForumSections

Erreurs, bugs, questions - page 2507

Nouveau commentaire
TheXpert:
Un tableau dynamique a plus de contrôles, Renat a écrit une fois, je ne peux pas trouver le post, juste parler de l'accès à l'index, pourquoi il est significativement plus lent que les plus.

Il s'avère que lorsque l'on remplit des tableaux dynamiques, il est préférable de remplir d'abord des tableaux statiques, puis d'effectuer des ArrayCopy vers des tableaux dynamiques.

fxsaber:
Quelle est la cause de ce ralentissement ?

Vous avez fait un tableau dynamique à partir d'un tableau statique. D'où tous les problèmes de type qui en résultent :

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

Lorsque la première et la deuxième boucle tournent à des vitesses différentes.

[Supprimé]
fxsaber:

Merci. C'est étrange, bien sûr. J'ai une différence stable.

Vict:

Merci. C'est étrange, bien sûr. J'ai une différence stable.

Je ne vois pas non plus de différence.
fxsaber:

Il s'avère que lorsque l'on remplit des tableaux dynamiques, il est préférable de remplir d'abord des tableaux statiques, puis d'effectuer des ArrayCopy vers des tableaux dynamiques.

C'est ainsi !

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:

Il l'est !

L'initialisation est généralement une opération ponctuelle et, la plupart du temps, vous n'avez pas à vous soucier de la vitesse. (plus frais de mémoire)

Mais s'il y a une référence constante par les index et que, par exemple, dans 99,9% des cas, la taille maximale du tableau est connue, il est probablement logique d'écrire un simple wrapper autour du tableau statique pour remplacer le tableau dynamique.

TheXpert:

L'initialisation est généralement une opération ponctuelle et, la plupart du temps, vous n'avez pas à vous soucier de la vitesse. (plus les frais de mémoire).

J'ai un enregistrement qui ralentit lors de l'analyse des ticks. Il y en a des dizaines de millions, donc ça compte.

Mais s'il y a des références constantes par index et que, par exemple, dans 99,9% des cas, la taille maximale du tableau est connue, il est probablement plus judicieux d'écrire un simple wrapper autour d'un tableau statique plutôt qu'un tableau dynamique.

Il pourrait être judicieux de faire un enveloppement sur la lecture également.


SZZ En lecture, je ne peux pas obtenir d'accélération.

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:

Il l'est !

mon fillarray1 est légèrement plus rapide

et la lecture est un désordre.

TheXpert:

mon fillarray1 est légèrement plus rapide

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

La version Release est en cours d'exécution. Optimisation activée.

fxsaber:

La version Release est en cours d'exécution. L'optimisation est activée.

Temps [FillArray1(Array1)] = 17732
Temps [FillArray2(Array2)] = 18808

Je ne sais pas ce que signifie la libération - j'ai compilé sur F7 (ça doit être ça) ME 2085

1...250025012502250325042505250625072508250925102511251225132514...3184
Nouveau commentaire