C# Décimal de type de données de performance

Vous dire qu'il doit être rapide, mais ne vous en béton exigences en matière de vitesse? Si non, vous pouvez ainsi optimiser passé le point de la folie 🙂

Comme un ami assis à côté de moi a juste suggéré, vous pouvez mettre à niveau votre matériel à la place? C'est probablement moins cher que de réécrire le code.

Le plus évident option est d'utiliser des entiers au lieu de décimales - où l'on "unité" est quelque chose comme "un millième de un cent" (ou ce que vous voulez - vous voyez l'idée). Si c'est faisable ou pas dépendra des opérations que vous effectuez sur les valeurs décimales pour commencer. Vous devez être très prudent lors de la manipulation, il est facile de faire des erreurs (au moins si vous êtes comme moi).

Ne le générateur de profils montrent notamment les points sensibles de votre application que vous pouvez optimiser individuellement? Par exemple, si vous avez besoin de faire beaucoup de calculs dans une petite zone de code, vous pouvez convertir un nombre décimal en un nombre entier de format, de faire les calculs et ensuite de les convertir en arrière. Qui pourrait empêcher l' API en termes de décimales pour l'essentiel du code, ce qui peut le rendre plus facile à maintenir. Toutefois, si vous n'avez pas prononcé de points d'accès, qui peut ne pas être faisable.

+1 pour le profilage et de nous dire que la vitesse est essentielle, btw 🙂

La question est discutée, mais depuis que je suis à creuser ce problème pendant un temps, je voudrais partager certaines de mes résultats.

La définition du problème: Décimales sont connus pour être beaucoup plus lent que des doubles mais les applications financières ne peuvent tolérer aucun des objets qui surviennent lorsque les calculs sont effectués sur les doubles.

Recherche

Mon objectif était de mesurer les différentes approches de stockage flottant de pointage de chiffres et de faire une conclusion qui doit être utilisé pour notre application.

S'était acceptable pour nous d'utiliser Int64 pour stocker des nombres à virgule flottante avec une précision fixe. Multiplicateur de 10^6 a été de nous donner à la fois: assez de chiffres pour enregistrer les fractions et stil une grande gamme de stocker de grandes quantités. Bien sûr, vous devez être prudent avec cette approche (la multiplication et de la division des opérations pourrait devenir compliqué), mais nous étions prêts et voulait mesurer cette approche. Une chose que vous devez garder à l'esprit à l'exception des éventuelles erreurs de calcul et les débordements, c'est que généralement on ne peut exposer ces nombres longs à l'API publique. Donc tous les calculs internes pourraient être effectuées à longs mais avant d'envoyer les nombres à l'utilisateur qu'il doit être converti en quelque chose de plus convivial.

J'ai implémenté un prototype simple classe qui encapsule une valeur de type long d'une virgule comme la structure (appelé Money) et de l'ajouter à l'arpentage.

public struct Money : IComparable
{
private readonly long _value;
public const long Multiplier = 1000000;
private const decimal ReverseMultiplier = 0.000001m;
public Money(long value)
{
_value = value;
}
public static explicit operator Money(decimal d)
{
return new Money(Decimal.ToInt64(d * Multiplier));
}
public static implicit operator decimal (Money m)
{
return m._value * ReverseMultiplier;
}
public static explicit operator Money(double d)
{
return new Money(Convert.ToInt64(d * Multiplier));
}
public static explicit operator double (Money m)
{
return Convert.ToDouble(m._value * ReverseMultiplier);
}
public static bool operator ==(Money m1, Money m2)
{
return m1._value == m2._value;
}
public static bool operator !=(Money m1, Money m2)
{
return m1._value != m2._value;
}
public static Money operator +(Money d1, Money d2)
{
return new Money(d1._value + d2._value);
}
public static Money operator -(Money d1, Money d2)
{
return new Money(d1._value - d2._value);
}
public static Money operator *(Money d1, Money d2)
{
return new Money(d1._value * d2._value / Multiplier);
}
public static Money operator /(Money d1, Money d2)
{
return new Money(d1._value / d2._value * Multiplier);
}
public static bool operator <(Money d1, Money d2)
{
return d1._value < d2._value;
}
public static bool operator <=(Money d1, Money d2)
{
return d1._value <= d2._value;
}
public static bool operator >(Money d1, Money d2)
{
return d1._value > d2._value;
}
public static bool operator >=(Money d1, Money d2)
{
return d1._value >= d2._value;
}
public override bool Equals(object o)
{
if (!(o is Money))
return false;
return this == (Money)o;
}
public override int GetHashCode()
{
return _value.GetHashCode();
}
public int CompareTo(object obj)
{
if (obj == null)
return 1;
if (!(obj is Money))
throw new ArgumentException("Cannot compare money.");
Money other = (Money)obj;
return _value.CompareTo(other._value);
}
public override string ToString()
{
return ((decimal) this).ToString(CultureInfo.InvariantCulture);
}
}

Expérience

J'ai mesuré opérations suivantes: addition, soustraction, multiplication, division, d'égalité et de comparaison relative (plus/moins), de la comparaison. J'ai été en mesure de les opérations sur les types suivants: double, long, decimal et Money. Chaque opération a été réalisée à 1.000.000 de fois. Tous les numéros ont été pré-alloués dans des tableaux, afin de l'appelant code personnalisé dans les constructeurs de decimal et Money ne devrait pas affecter les résultats.

Added moneys in 5.445 ms
Added decimals in 26.23 ms
Added doubles in 2.3925 ms
Added longs in 1.6494 ms
Subtracted moneys in 5.6425 ms
Subtracted decimals in 31.5431 ms
Subtracted doubles in 1.7022 ms
Subtracted longs in 1.7008 ms
Multiplied moneys in 20.4474 ms
Multiplied decimals in 24.9457 ms
Multiplied doubles in 1.6997 ms
Multiplied longs in 1.699 ms
Divided moneys in 15.2841 ms
Divided decimals in 229.7391 ms
Divided doubles in 7.2264 ms
Divided longs in 8.6903 ms
Equility compared moneys in 5.3652 ms
Equility compared decimals in 29.003 ms
Equility compared doubles in 1.727 ms
Equility compared longs in 1.7547 ms
Relationally compared moneys in 9.0285 ms
Relationally compared decimals in 29.2716 ms
Relationally compared doubles in 1.7186 ms
Relationally compared longs in 1.7321 ms

Conclusions

1. L'Addition, la soustraction, la multiplication, les opérations de comparaison sur decimal sont ~15 fois plus lent que les opérations sur long ou double; la division est de ~30 fois plus lent.
2. Performance de Decimal-comme wrapper est meilleure que la performance de Decimal mais encore bien pire que la performance de double et long en raison du manque de soutien de la CLR.
3. Effectuer des calculs sur Decimal en chiffres absolus est très rapide: 40.000.000 d'opérations par seconde.

Conseils

1. Moins d'avoir une très lourde cas de calcul, l'utilisation des décimales. En nombres relatifs, ils sont plus lents que les longs et les doubles, mais les nombres absolus de bien paraître.
2. Il n'y a pas beaucoup de point dans la re-mise en œuvre de Decimal avec votre propre structure en raison de la abcense de soutien de la CLR. Vous pourriez en faire plus vite que Decimal mais il ne sera jamais aussi rapide que double.
3. Si les performances de Decimal n'est pas suffisant pour votre application, que vous pourriez envisager de passer vos calculs long fixe avec précision. Avant de retourner le résultat au client, il doit être converti à Decimal.

Ce sujet MMX/SSE/SSE2?

je pense que ça va aider...
alors...
virgule est 128 bits type de données et SSE2 est 128bit trop... et il peut ajouter, sous, div, mul décimal de 1 graduation de l'UC...

vous pouvez écrire DLL pour SSE2 à l'aide de VC++ et ensuite utiliser cette DLL dans votre application

e.g
//vous pouvez faire quelque chose comme ceci

VC++

#include <emmintrin.h>
#include <tmmintrin.h>
extern "C" DllExport __int32* sse2_add(__int32* arr1, __int32* arr2);
extern "C" DllExport __int32* sse2_add(__int32* arr1, __int32* arr2)
{
__m128i mi1 = _mm_setr_epi32(arr1[0], arr1[1], arr1[2], arr1[3]);
__m128i mi2 = _mm_setr_epi32(arr2[0], arr2[1], arr2[2], arr2[3]);
__m128i mi3 = _mm_add_epi32(mi1, mi2);
__int32 rarr[4] = { mi3.m128i_i32[0], mi3.m128i_i32[1], mi3.m128i_i32[2], mi3.m128i_i32[3] };
return rarr;
}

C#

[DllImport("sse2.dll")]
private unsafe static extern int[] sse2_add(int[] arr1, int[] arr2);
public unsafe static decimal addDec(decimal d1, decimal d2)
{
int[] arr1 = decimal.GetBits(d1);
int[] arr2 = decimal.GetBits(d2);
int[] resultArr = sse2_add(arr1, arr2);
return new decimal(resultArr);
}

Je ne peux pas donner un commentaire ou un vote encore car je viens de commencer sur un débordement de pile. Mon commentaire sur alexsmart (posté le 23 Dec 2008 12:31), c'est que l'expression Round(n/précision, précision), où n est de type int et précisions est long ne fera pas ce qu'il pense:

1) n/précision sera de retour un entier de la division, c'est à dire qu'il sera déjà bien arrondi, mais vous ne serez pas en mesure d'utiliser toutes les décimales. L'arrondissement de comportement est également différente de celle des Mathématiques.Tour(...).

2) Le code "retour de Mathématiques.Round(n/précision, précision).ToString()" ne compile pas en raison d'une ambiguïté entre les Mathématiques.Round(double, int) et des Mathématiques.Ronde(décimal, int). Vous aurez à jeter à la décimale (pas en double, car il est un financière de l'app) et, par conséquent, peut aussi bien aller avec décimale, en premier lieu.

3) n/précision, où la précision est de 4 ne sera pas tronquée à quatre décimales, mais diviser par 4. E. g., Mathématiques.Round( (décimal) (1234567/4), 4) retourne 308641. (1234567/4 = 308641.75), tout ce que vous avez probablement voulu pour se 1235000 (arrondie à une précision de 4 chiffres à partir de la fin 567). Notez que les Mathématiques.Ronde permet d'arrondir à un point fixe, pas une précision fixe.

Mise à jour: je peux ajouter des commentaires maintenant, mais il n'y a pas assez de place pour mettre celui-ci dans la zone de commentaire.