Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Zazar
Bonjour,
Est-il plus efficace de faire Array.Clear(xx,xx,xx) ou Redim ?
Je suppose que la première méthode est une boucle mettant tous les champs à null/0, et que la 2ième consiste en une désallocation/allocation de mémoire. Si c'est le cas : la première méthode est plutôt rapide, tandis qu'allouer puis réallouer de la mémoire est extrémement couteux. De plus, ça peut fragmenter la mémoire et impliquer un changement de génération (du point de vue du GC) de votre tableau (si il était en 0 par exemple, il va se retrouver en 2 pour peut-être être redéplacer en 1 puis en 0). Autrement le Array.Clear() est nettement préfèrable. Cependant, si votre tableau est en dernière génération, à "la fin du tas" (c'est typiquement le cas, quand c'est le dernier objet à avoir été alloué et que le GC n'a pas fonctionné depuis (voire même surement s'il a fonctionné, mais là j'en suis pas certain)), alors la désallocation de la mémoire/réallocation est assez rapide grâce au modèle de gestion de la mémoire de .NET. En gros, quand on a plus besoin d'un objet, .NET ne rend pas la mémoire à l'OS (sauf si la mémoire restante est faible) et la garde au cas où. Dans cette situation idéale, la désallocation/réallocation se passera mieux et à mon avis, il est alors possible que pour les très gros tableaux, le redim soit plus rapide que le Clear; la notion de "très gros" dépendant de votre PC et de l'OS. Conclusion : en théorie, il vaut mieux utiliser Array.Clear(). Mais même si là je pense pas m'être trompé, dès qu'on veut comparer des performances, le mieux c'est d'implémenter les deux solutions, de les faire tourner dans des conditions réélles d'utilisation et de faire des mesures.
-- Zazar
Bonjour,
Est-il plus efficace de faire Array.Clear(xx,xx,xx) ou Redim ?
Je suppose que la première méthode est une boucle mettant tous les champs à
null/0, et que la 2ième consiste en une désallocation/allocation de mémoire.
Si c'est le cas : la première méthode est plutôt rapide, tandis qu'allouer
puis réallouer de la mémoire est extrémement couteux. De plus, ça peut
fragmenter la mémoire et impliquer un changement de génération (du point de
vue du GC) de votre tableau (si il était en 0 par exemple, il va se
retrouver en 2 pour peut-être être redéplacer en 1 puis en 0). Autrement le
Array.Clear() est nettement préfèrable.
Cependant, si votre tableau est en dernière génération, à "la fin du tas"
(c'est typiquement le cas, quand c'est le dernier objet à avoir été alloué
et que le GC n'a pas fonctionné depuis (voire même surement s'il a
fonctionné, mais là j'en suis pas certain)), alors la désallocation de la
mémoire/réallocation est assez rapide grâce au modèle de gestion de la
mémoire de .NET. En gros, quand on a plus besoin d'un objet, .NET ne rend
pas la mémoire à l'OS (sauf si la mémoire restante est faible) et la garde
au cas où. Dans cette situation idéale, la désallocation/réallocation se
passera mieux et à mon avis, il est alors possible que pour les très gros
tableaux, le redim soit plus rapide que le Clear; la notion de "très gros"
dépendant de votre PC et de l'OS.
Conclusion : en théorie, il vaut mieux utiliser Array.Clear().
Mais même si là je pense pas m'être trompé, dès qu'on veut comparer des
performances, le mieux c'est d'implémenter les deux solutions, de les faire
tourner dans des conditions réélles d'utilisation et de faire des mesures.
Est-il plus efficace de faire Array.Clear(xx,xx,xx) ou Redim ?
Je suppose que la première méthode est une boucle mettant tous les champs à null/0, et que la 2ième consiste en une désallocation/allocation de mémoire. Si c'est le cas : la première méthode est plutôt rapide, tandis qu'allouer puis réallouer de la mémoire est extrémement couteux. De plus, ça peut fragmenter la mémoire et impliquer un changement de génération (du point de vue du GC) de votre tableau (si il était en 0 par exemple, il va se retrouver en 2 pour peut-être être redéplacer en 1 puis en 0). Autrement le Array.Clear() est nettement préfèrable. Cependant, si votre tableau est en dernière génération, à "la fin du tas" (c'est typiquement le cas, quand c'est le dernier objet à avoir été alloué et que le GC n'a pas fonctionné depuis (voire même surement s'il a fonctionné, mais là j'en suis pas certain)), alors la désallocation de la mémoire/réallocation est assez rapide grâce au modèle de gestion de la mémoire de .NET. En gros, quand on a plus besoin d'un objet, .NET ne rend pas la mémoire à l'OS (sauf si la mémoire restante est faible) et la garde au cas où. Dans cette situation idéale, la désallocation/réallocation se passera mieux et à mon avis, il est alors possible que pour les très gros tableaux, le redim soit plus rapide que le Clear; la notion de "très gros" dépendant de votre PC et de l'OS. Conclusion : en théorie, il vaut mieux utiliser Array.Clear(). Mais même si là je pense pas m'être trompé, dès qu'on veut comparer des performances, le mieux c'est d'implémenter les deux solutions, de les faire tourner dans des conditions réélles d'utilisation et de faire des mesures.
-- Zazar
Bismark Prods
Merci c'est très agréable d'avoir des réponses si complète.
Bonne journée
"Zazar" a écrit dans le message de news:
Bonjour,
> Est-il plus efficace de faire Array.Clear(xx,xx,xx) ou Redim ?
Je suppose que la première méthode est une boucle mettant tous les champs
à
null/0, et que la 2ième consiste en une désallocation/allocation de
mémoire.
Si c'est le cas : la première méthode est plutôt rapide, tandis qu'allouer puis réallouer de la mémoire est extrémement couteux. De plus, ça peut fragmenter la mémoire et impliquer un changement de génération (du point
de
vue du GC) de votre tableau (si il était en 0 par exemple, il va se retrouver en 2 pour peut-être être redéplacer en 1 puis en 0). Autrement
le
Array.Clear() est nettement préfèrable. Cependant, si votre tableau est en dernière génération, à "la fin du tas" (c'est typiquement le cas, quand c'est le dernier objet à avoir été alloué et que le GC n'a pas fonctionné depuis (voire même surement s'il a fonctionné, mais là j'en suis pas certain)), alors la désallocation de la mémoire/réallocation est assez rapide grâce au modèle de gestion de la mémoire de .NET. En gros, quand on a plus besoin d'un objet, .NET ne rend pas la mémoire à l'OS (sauf si la mémoire restante est faible) et la garde au cas où. Dans cette situation idéale, la désallocation/réallocation se passera mieux et à mon avis, il est alors possible que pour les très gros tableaux, le redim soit plus rapide que le Clear; la notion de "très gros" dépendant de votre PC et de l'OS. Conclusion : en théorie, il vaut mieux utiliser Array.Clear(). Mais même si là je pense pas m'être trompé, dès qu'on veut comparer des performances, le mieux c'est d'implémenter les deux solutions, de les
faire
tourner dans des conditions réélles d'utilisation et de faire des mesures.
-- Zazar
Merci c'est très agréable d'avoir des réponses si complète.
Bonne journée
"Zazar" <DILAVNI.nicolas.prats@iie.cnam.fr.INVALID> a écrit dans le message
de news:uHfDjnfWEHA.204@TK2MSFTNGP10.phx.gbl...
Bonjour,
> Est-il plus efficace de faire Array.Clear(xx,xx,xx) ou Redim ?
Je suppose que la première méthode est une boucle mettant tous les champs
à
null/0, et que la 2ième consiste en une désallocation/allocation de
mémoire.
Si c'est le cas : la première méthode est plutôt rapide, tandis qu'allouer
puis réallouer de la mémoire est extrémement couteux. De plus, ça peut
fragmenter la mémoire et impliquer un changement de génération (du point
de
vue du GC) de votre tableau (si il était en 0 par exemple, il va se
retrouver en 2 pour peut-être être redéplacer en 1 puis en 0). Autrement
le
Array.Clear() est nettement préfèrable.
Cependant, si votre tableau est en dernière génération, à "la fin du tas"
(c'est typiquement le cas, quand c'est le dernier objet à avoir été alloué
et que le GC n'a pas fonctionné depuis (voire même surement s'il a
fonctionné, mais là j'en suis pas certain)), alors la désallocation de la
mémoire/réallocation est assez rapide grâce au modèle de gestion de la
mémoire de .NET. En gros, quand on a plus besoin d'un objet, .NET ne rend
pas la mémoire à l'OS (sauf si la mémoire restante est faible) et la garde
au cas où. Dans cette situation idéale, la désallocation/réallocation se
passera mieux et à mon avis, il est alors possible que pour les très gros
tableaux, le redim soit plus rapide que le Clear; la notion de "très gros"
dépendant de votre PC et de l'OS.
Conclusion : en théorie, il vaut mieux utiliser Array.Clear().
Mais même si là je pense pas m'être trompé, dès qu'on veut comparer des
performances, le mieux c'est d'implémenter les deux solutions, de les
faire
tourner dans des conditions réélles d'utilisation et de faire des mesures.
Merci c'est très agréable d'avoir des réponses si complète.
Bonne journée
"Zazar" a écrit dans le message de news:
Bonjour,
> Est-il plus efficace de faire Array.Clear(xx,xx,xx) ou Redim ?
Je suppose que la première méthode est une boucle mettant tous les champs
à
null/0, et que la 2ième consiste en une désallocation/allocation de
mémoire.
Si c'est le cas : la première méthode est plutôt rapide, tandis qu'allouer puis réallouer de la mémoire est extrémement couteux. De plus, ça peut fragmenter la mémoire et impliquer un changement de génération (du point
de
vue du GC) de votre tableau (si il était en 0 par exemple, il va se retrouver en 2 pour peut-être être redéplacer en 1 puis en 0). Autrement
le
Array.Clear() est nettement préfèrable. Cependant, si votre tableau est en dernière génération, à "la fin du tas" (c'est typiquement le cas, quand c'est le dernier objet à avoir été alloué et que le GC n'a pas fonctionné depuis (voire même surement s'il a fonctionné, mais là j'en suis pas certain)), alors la désallocation de la mémoire/réallocation est assez rapide grâce au modèle de gestion de la mémoire de .NET. En gros, quand on a plus besoin d'un objet, .NET ne rend pas la mémoire à l'OS (sauf si la mémoire restante est faible) et la garde au cas où. Dans cette situation idéale, la désallocation/réallocation se passera mieux et à mon avis, il est alors possible que pour les très gros tableaux, le redim soit plus rapide que le Clear; la notion de "très gros" dépendant de votre PC et de l'OS. Conclusion : en théorie, il vaut mieux utiliser Array.Clear(). Mais même si là je pense pas m'être trompé, dès qu'on veut comparer des performances, le mieux c'est d'implémenter les deux solutions, de les
faire
tourner dans des conditions réélles d'utilisation et de faire des mesures.
-- Zazar
Zazar
> Merci c'est très agréable d'avoir des réponses si complète.
Et qui contiennent des erreurs :)
Contrairement à ce que j'ai laissé sous-entendre, les nouveaux objets sont en génération 0, puis leurs générations augmentent au fur et à mesure des exécutions du GC.
-- Zazar
> Merci c'est très agréable d'avoir des réponses si complète.
Et qui contiennent des erreurs :)
Contrairement à ce que j'ai laissé sous-entendre, les nouveaux objets sont
en génération 0, puis leurs générations augmentent au fur et à mesure des
exécutions du GC.
> Merci c'est très agréable d'avoir des réponses si complète.
Et qui contiennent des erreurs :)
Contrairement à ce que j'ai laissé sous-entendre, les nouveaux objets sont en génération 0, puis leurs générations augmentent au fur et à mesure des exécutions du GC.
