Optimisation d'une initialisation tableau

Version imprimable

Bonjour,

j'aimerais trouvé un moyen d'optimiser ce bout de code qui prend trop de temps malheureusement, j'aurais besoin de vos lumières

Je souhaiterais initialiser des tableaux n dimensions tres rapidement,
la valeur a insérer dans les tableaux est 0

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
 
/**
   * Nom : initArray(double[][] p_Tab, int p_Col, int p_Line)<br>
   * Description : Initialisation d'un tableau deux dimensions<br>
   * 
   * @param p_Tab
   *          tableau
   * @param p_Col
   *          colonnes
   * @param p_Line
   *          lignes
   * @return tableau initialise
   */
  public static double[][] initArray(double[][] p_Tab, int p_Col, int p_Line) {
    // ---------------------------------------------------------------
    // Declaration des variables necessaires
    // ---------------------------------------------------------------
    int c = 0;
 
    // ---------------------------------------------------------------
    // On instancie le tableau
    // ---------------------------------------------------------------
    if (p_Tab == null) {
      p_Tab = new double[p_Col][p_Line];
    }
    else {
      // ---------------------------------------------------------------
      // On init le tableau
      // ---------------------------------------------------------------
      for (c = 0; c < p_Col; c++) {
        System.arraycopy(s_DblList, 0, p_Tab[c], 0, p_Line);
      }
    }
 
    return p_Tab;
  }

11/08/2009, 02h22
entreprise38

Salut,

pour savoir où chercher : qu'est-ce qui prend le plus de temps ? La création d'un tableau n*m, ou le remplissage d'un tableau n*m ?
Si c'est le remplissage alors t'embêtes pas, recréés en un.

Ensuite, as-tu vraiment besoin d'un tableau n*m ? Une map (avec une clef composée d'autant de valeurs que tu veux de dimensions) n'irait pas ?
11/08/2009, 09h37
pyth35

Alors j'ai besoin de ce genre de tableau et de les initialiser souvent parce que je suis dans du calcul numérique bouclé.

Le nombre de boucle est lié au temps de la simulation. 1 boucle pour une seconde.

Donc concrètement cette méthode est appelé très souvent, et dans mon calcul numérique elle prend 80% du temps consommé. J'aimerais pouvoir l'optimiser pour qu'elle puisse prendre le moins de temps possible.

Le problème de créer sans arrêt des tableaux risque sans doute d'exploser la mémoire.

Ai-je été assez clair? ou dois-je reformuler ma demande?
11/08/2009, 12h35
ttttnht
Bonjour,

Peut-on savoir c'est quoi cet objet?

Citation:

DblList

que tu utlises dans cette ligne
Code:

1 2 System.arraycopy(s_DblList, 0, p_Tab[c], 0, p_Line);
11/08/2009, 13h48
in

Je ne sais pas si ça va améliorer tes perfs mais tu peux regarder la méthode fill(...) de la classe Arrays
11/08/2009, 13h56
pyth35

/** Taille des listes. */
private static final int s_SizeList = 1000;
/** Listes de double. */
private static final double[] s_DblList = new double[s_SizeList];

Pour gagner du temps, c'est une liste en constante qui contient que des 0 pour les recopier, en faisant ca je divise par 3 le temps

J'ai fait ca pour eviter de faire une double boucle et mettre 0 au tableau en fonction de la ligne et la colonne tab[col][ligne] = 0.0
11/08/2009, 14h06
pyth35

En utilisant fill de la classe Arrays c'est un peu plus long que d'utiliser le System.arrayscopy

merci quand meme
11/08/2009, 14h16
Djobird

Mais je comprend pas trop en fait, tu veux initialiser des tableaux avec toutes les valeurs à 0 ?
Parce que c'est comme ca par défaut en fait Oo
11/08/2009, 14h25
pyth35

Oui je sais, mais comme je l'ai dit précédemment c'est un calcul numérique bouclé, donc pour une boucle on calcul des choses, les tableaux se remplissent et pour la seconde boucle on a besoin de les réinitialiser a la valeur 0 pour de nouveau faire des calculs et éviter un chevauchement avec les calculs précédent (pour éviter les erreurs de calcul)

Tu vois mieux le problème??
11/08/2009, 14h32
pyth35

J'ai gagner une dixième de seconde en déclarant le c dans la boucle (for (int c = 0;)

j'ai économisé deux instructions.
11/08/2009, 14h36
Djobird

Oui, et je comprend mieux ta phrase "Le problème de créer sans arrêt des tableaux risque sans doute d'exploser la mémoire.".

Mais je ne suis par contre pas sur d'être d'accord avec ca vu que tes tableaux sont détruies à chaque fois. Certe si tu dois créer/détruire beaucoup de tableau, le garbage collector va être sollicité et ralentir l'application, mais ca ne sera rien comparer à ce que tu fais comme autre calcul.
11/08/2009, 15h16
Yomhgui
Le problème de la réallocation d'un tableau à chaque utilisation est que le "new" est une opération qui coute cher (probablement beaucoup plus que l'initialisation du tableau lui-même) et qu'en plus ça va générer du travail supplémentaire pour le garbage collector qui va devoir prendre en charge la destruction des instances inutilisées du tableau.

As-tu essayé de passer par un tableau à une dimension en faisant toi-même les calculs d'indexation pour "faire comme si" tu avais un tableau à deux dimensions ? Ça te permettra d'améliorer l'utilisation du System.arraycopy() pour faire le remplissage de tout le tableau avec le modèle vide en une seule passe et, pour ce qui est des calculs d'index, il sont faits de la même manière si tu utilises un tableau à deux dimension donc ça ne devrait pas prendre plus de temps.

Par ailleurs (c'est une toute petite optimisation mais en calcul scientifique, il n'y a pas de petites économies), tu peux surement t'arranger pour ne pas faire le test if (p_Tab == null) à chaque tour de boucle.

Est-ce que tu as vraiment besoin de calculer en "double" ? Si tu es sur une architecture 32 bits et que tu fais des calculs lourds sur des données 64 bits alors que ça n'est pas nécessaire, ça peut être pénalisant.

Si avec ces trucs là, ça ne donne rien de probant, je ne vois pas des tonnes d'autres solutions directes (aucune en fait). Après, il y a:
- Le passage en C++ et tu codes ton init de tableau bien optimisée avec de l'assembleur inline,...:(
- Des optimisations très dépendantes du contexte technique. As-tu besoin de toutes les valeurs dans le tableau (quand on utilise des matrices carrées, on peut faire de manière immédiate une grosse optimisation si elles sont symétriques) ? Est-ce que tu es vraiment obligé de ré-initialiser (dans certains calculs, on peut avancer dans un tableau en calculant une donnée à partir des valeurs qui précèdent ce qui permet de ne pas remettre à zéro les valeurs qui suivent). Bon, c'est vraiment pour te donner un embryon de fœtus de piste ; mais sans en savoir plus sur le contexte...:?
Bon courage