Performance surprise “avec” et des types nullables

Il me semble que la isinst est vraiment lent sur les types nullables. Dans la méthode FindSumWithCast j'ai changé

if (o is int)

à

if (o is int?)

qui a également ralentit considérablement l'exécution. La seule differenc dans IL je peux voir, c'est que

isinst     [mscorlib]System.Int32

est changé à

isinst     valuetype [mscorlib]System.Nullable`1<int32>

OriginalL'auteur Dirk Vollmar

Fait intéressant, je suis passé sur les commentaires à propos de soutien aux opérateurs via dynamic étant un ordre de grandeur plus lent pour Nullable<T> (similaire à ce début de test) - je soupçonne, pour des raisons très semblables.

Gotta love Nullable<T>. Un autre plaisir est que même si l'équipe des taches (et supprime) null pour non nullable les structures, il borks pour Nullable<T>:

using System;
using System.Diagnostics;
static class Program {
static void Main() { 
//JIT
TestUnrestricted<int>(1,5);
TestUnrestricted<string>("abc",5);
TestUnrestricted<int?>(1,5);
TestNullable<int>(1, 5);
const int LOOP = 100000000;
Console.WriteLine(TestUnrestricted<int>(1, LOOP));
Console.WriteLine(TestUnrestricted<string>("abc", LOOP));
Console.WriteLine(TestUnrestricted<int?>(1, LOOP));
Console.WriteLine(TestNullable<int>(1, LOOP));
}
static long TestUnrestricted<T>(T x, int loop) {
Stopwatch watch = Stopwatch.StartNew();
int count = 0;
for (int i = 0; i < loop; i++) {
if (x != null) count++;
}
watch.Stop();
return watch.ElapsedMilliseconds;
}
static long TestNullable<T>(T? x, int loop) where T : struct {
Stopwatch watch = Stopwatch.StartNew();
int count = 0;
for (int i = 0; i < loop; i++) {
if (x != null) count++;
}
watch.Stop();
return watch.ElapsedMilliseconds;
}
}

OriginalL'auteur Marc Gravell

Profilage plus loin:

using System;
using System.Diagnostics;
class Program
{
const int Size = 30000000;
static void Main(string[] args)
{
object[] values = new object[Size];
for (int i = 0; i < Size - 2; i += 3)
{
values[i] = null;
values[i + 1] = "";
values[i + 2] = 1;
}
FindSumWithIsThenCast(values);
FindSumWithAsThenHasThenValue(values);
FindSumWithAsThenHasThenCast(values);
FindSumWithManualAs(values);
FindSumWithAsThenManualHasThenValue(values);
Console.ReadLine();
}
static void FindSumWithIsThenCast(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
if (o is int)
{
int x = (int)o;
sum += x;
}
}
sw.Stop();
Console.WriteLine("Is then Cast: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithAsThenHasThenValue(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
int? x = o as int?;
if (x.HasValue)
{
sum += x.Value;
}
}
sw.Stop();
Console.WriteLine("As then Has then Value: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithAsThenHasThenCast(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
int? x = o as int?;
if (x.HasValue)
{
sum += (int)o;
}
}
sw.Stop();
Console.WriteLine("As then Has then Cast: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithManualAs(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
bool hasValue = o is int;
int x = hasValue ? (int)o : 0;
if (hasValue)
{
sum += x;
}
}
sw.Stop();
Console.WriteLine("Manual As: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithAsThenManualHasThenValue(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
int? x = o as int?;
if (o is int)
{
sum += x.Value;
}
}
sw.Stop();
Console.WriteLine("As then Manual Has then Value: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
}

De sortie:

Is then Cast: 10000000 : 303
As then Has then Value: 10000000 : 3524
As then Has then Cast: 10000000 : 3272
Manual As: 10000000 : 395
As then Manual Has then Value: 10000000 : 3282

Que pouvons-nous déduire de ces chiffres?

• Tout d'abord, est-puis-cast approche est nettement plus rapide que comme approche. 303 vs 3524
• Seconde .La valeur est légèrement plus lent que le casting. 3524 vs 3272
• Troisième, .HasValue est légèrement plus lente que l'utilisation du manuel(c'est à dire à l'aide de est). 3524 vs 3282
• Quatrième, faire une pomme à la pomme de comparaison(c'est à dire à la fois l'attribution de simulation de HasValue et la conversion de la Valeur simulée arrive ensemble) entre simulé et réel que approche, nous pouvons voir simulé est toujours beaucoup plus rapide que réel que. 395 vs 3524
• Enfin, sur la base des premier et quatrième conclusion, il y a quelque chose de mal avec comme
  la mise en œuvre ^_^

OriginalL'auteur

J'ai essayé le type exact de vérifier construire

typeof(int) == item.GetType(), qui effectue aussi vite que le item is int version, et renvoie toujours la numéro (attention: même si vous avez écrit un Nullable<int> dans le tableau, vous devez utiliser typeof(int)). Vous avez également besoin d'un supplément de null != item vérifier ici.

Cependant

typeof(int?) == item.GetType() reste rapide (contrairement à item is int?), mais renvoie toujours false.

La typeof-construire, c'est à mes yeux le moyen le plus rapide pour exacte vérification de type, comme il utilise le Propriétaire. Depuis les types exacts dans ce cas, ne correspondent pas avec les valeurs null, ma conjecture est, is/as avoir à faire de nouvelles heavylifting ici à s'assurer qu'il est en fait une instance d'un type Nullable.

Et honnêtement: qu'est-ce que votre is Nullable<xxx> plus HasValue vous acheter? Rien. Vous pouvez toujours vous rendre directement à la sous-jacent (valeur) type (dans ce cas). Vous obtenez soit la valeur ou "non, pas un exemple du type demandaient". Même si vous avez écrit (int?)null de la matrice, la vérification de type retourne la valeur false.

OriginalL'auteur dalo

using System;
using System.Diagnostics;
using System.Linq;
class Test
{
const int Size = 30000000;
static void Main()
{
object[] values = new object[Size];
for (int i = 0; i < Size - 2; i += 3)
{
values[i] = null;
values[i + 1] = "";
values[i + 2] = 1;
}
FindSumWithCast(values);
FindSumWithAsAndHas(values);
FindSumWithAsAndIs(values);
FindSumWithIsThenAs(values);
FindSumWithIsThenConvert(values);
FindSumWithLinq(values);
Console.ReadLine();
}
static void FindSumWithCast(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
if (o is int)
{
int x = (int)o;
sum += x;
}
}
sw.Stop();
Console.WriteLine("Cast: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithAsAndHas(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
int? x = o as int?;
if (x.HasValue)
{
sum += x.Value;
}
}
sw.Stop();
Console.WriteLine("As and Has: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithAsAndIs(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
int? x = o as int?;
if (o is int)
{
sum += x.Value;
}
}
sw.Stop();
Console.WriteLine("As and Is: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithIsThenAs(object[] values)
{
//Apple-to-apple comparison with Cast routine above.
//Using the similar steps in Cast routine above,
//the AS here cannot be slower than Linq.
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{
if (o is int)
{
int? x = o as int?;
sum += x.Value;
}
}
sw.Stop();
Console.WriteLine("Is then As: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithIsThenConvert(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = 0;
foreach (object o in values)
{            
if (o is int)
{
int x = Convert.ToInt32(o);
sum += x;
}
}
sw.Stop();
Console.WriteLine("Is then Convert: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
static void FindSumWithLinq(object[] values)
{
Stopwatch sw = Stopwatch.StartNew();
int sum = values.OfType<int>().Sum();
sw.Stop();
Console.WriteLine("LINQ: {0} : {1}", sum,
(long)sw.ElapsedMilliseconds);
}
}

Sorties:

Cast: 10000000 : 456
As and Has: 10000000 : 2103
As and Is: 10000000 : 2029
Is then As: 10000000 : 1376
Is then Convert: 10000000 : 566
LINQ: 10000000 : 1811

[EDIT: 2010-06-19]

Remarque: test Précédent a été fait à l'intérieur de VS, la configuration de débogage, à l'aide de VS2009, à l'aide de Core i7(société de développement de la machine).

Ce qui suit a été fait sur ma machine à l'aide des Core 2 Duo, à l'aide de VS2010

Inside VS, Configuration: Debug
Cast: 10000000 : 309
As and Has: 10000000 : 3322
As and Is: 10000000 : 3249
Is then As: 10000000 : 1926
Is then Convert: 10000000 : 410
LINQ: 10000000 : 2018
Outside VS, Configuration: Debug
Cast: 10000000 : 303
As and Has: 10000000 : 3314
As and Is: 10000000 : 3230
Is then As: 10000000 : 1942
Is then Convert: 10000000 : 418
LINQ: 10000000 : 1944
Inside VS, Configuration: Release
Cast: 10000000 : 305
As and Has: 10000000 : 3327
As and Is: 10000000 : 3265
Is then As: 10000000 : 1942
Is then Convert: 10000000 : 414
LINQ: 10000000 : 1932
Outside VS, Configuration: Release
Cast: 10000000 : 301
As and Has: 10000000 : 3274
As and Is: 10000000 : 3240
Is then As: 10000000 : 1904
Is then Convert: 10000000 : 414
LINQ: 10000000 : 1936

OriginalL'auteur Michael Buen