cogimator.net

Une ligne à la fois...

Implémentation naïve d'un Serializer en C# - Partie 7

La dernière ligne droite dans l’implémentation de ce Serializer était d’avoir des performances similaires (ou meilleures!) à celles du BinaryFormatter du Framework .Net. En utilisant uniquement la reflection, ce n’était pas gagné d’avance.

foreach (var prop in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).OrderBy(x => x.Name))
{
    var v = this.DeserializeBase(prop.FieldType, destination, source);

    prop.SetValue(destination, v);
}

En effet, a chaque serialisation de la meme classe, ce code va récupérer les champs, encore et encore, ce qui n'est de loin pas efficace.

L’optimisation que j’ai choisi a été de remplacer l’utilisation de la reflection par la création de LambdaExpression basées sur les champs des objets a sérialiser.

gettersForType = new List<Tuple<Type, Func<object, object>>>();

// create getter list from fields
foreach (var prop in sourceType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public))
{
    var getters = CreateGetter(prop);

    gettersForType.Add(Tuple.Create(prop.FieldType, getters));
}

Ici, la reflection sera utilisée une fois pour obtenir la liste des champs, et générer les Getters qui permettront d'en lire les valeurs.

La méthode CreateGetter va retourner un Func après avoir crée et compilé une LambdaExpression.

private static Func<object, object> CreateGetter(FieldInfo field)
{
    var fieldType = field.DeclaringType;

    // the input parameter for the lambda
    var sourceParameter = Expression.Parameter(typeof(object), "source");

    // as the parameter is of object type, a cast or conversion may be required
    var castedSource = GetExpressionAsTypeIfNeeded(sourceParameter, fieldType);

    // get field value
    var fieldExpression = Expression.Field(castedSource, field);

    // as the return parameter is of type object, a cast or conversion may be required
    var castedField = Expression.TypeAs(fieldExpression, typeof(object));

    // the lambda expression for accessing a field on an object
    var expr = Expression.Lambda<Func<object, object>>(castedField, sourceParameter);
    return expr.Compile();
}

Les éléments clés dans cette méthode sont :

  • La déclaration d’un paramètre pour la LambdaExpression, de type object, qui sera casté ou converti dans le bon type. En effet, comme on ne connait pas en avance le type de l’objet que l’on va désérialiser, la signature de la lambda expression est Func<object,object>.
  • La récupération d’une expression renvoyant la valeur du champ
  • Le cast de cette valeur en object pour la renvoyer.

De la même manière, j’avais implémenté une méthode CreateSetter, qui elle renvoyait un Action<object,object>. Cette méthode, créée a la volée pour un champ donné, prenait en paramètre l’objet en cours de désérialisation, ainsi que la valeur a assigner au champ.

private static Action<object, object> CreateSetter(FieldInfo field)
{
    var fieldType = field.DeclaringType;

    // the input parameter for the lambda
    var destinationParameter = Expression.Parameter(typeof(object), "destination");
    var valueParameter = Expression.Parameter(typeof(object), "fieldValue");

    var castedDestination = GetExpressionAsTypeIfNeeded(destinationParameter, fieldType);
    var castedValue = GetExpressionAsTypeIfNeeded(valueParameter, field.FieldType);

    // get field value
    var fieldExpression = Expression.Field(castedDestination, field);

    // as the return parameter is of type object, a cast or conversion may be required
    var assign = Expression.Assign(fieldExpression, castedValue);

    // the lambda expression for accessing a field on an object
    var expr = Expression.Lambda<Action<object, object>>(assign, destinationParameter, valueParameter);
    return expr.Compile();
}

Le souci de cette méthode est quelle renvoie un Action<object,object>. Or si les types valeurs “basiques” comme int, long, float, ne posent pas de souci, comme ils sont gérés par un sérializer a part, les structs, qui sont également passés par valeurs, ne sont pas désérialisés !

En effet, la méthode va agir sur une copie de l’instance en cours de désérialisation, dont les champs garderont les valeurs par défaut.

J’ai donc choisi d’implémenter une méthode plus complète, qui va non seulement générer le code pour définir les valeurs des champs, mais également prendre en charge la création de l’instance qui va être désérialisée. Cette méthode renvoie une fonction, qui prend en paramètre le flux dans lequel lire les valeurs a désérialiser, l’instance de l’objet sur laquelle seront définies les champs, et qui retourne l’instance désérialisée.

Dans le cas des types valeurs, la fonction générée se charge de la création de l’instance, et la retourne. De ce fait, on ne souffre plus des problèmes posés par l’implémentation précédente.

private Func<ExtendedBinaryReader, object, object> CreateSetters(Type type)
{
    // the input parameters of the generated lambda : the destination instance on which the setters will be applied
    var destinationParameter = Expression.Parameter(typeof(object), "destination");

    // the BinaryReader from which to get the data
    var binaryReaderParameter = Expression.Parameter(typeof(ExtendedBinaryReader), "source");

    // a variable to hold the destination instance
    var deserializedType = Expression.Variable(type, "destination");

    var expressionBlock = new List<Expression>();

    if (!type.IsValueType)
    {
        // if the type is not a value type the instance given as a parameter is used, or a new instance is created
        var coalesce = Expression.Coalesce(GetExpressionAsTypeIfNeeded(destinationParameter, type), Expression.New(type));

        // the first "line" of the lambda is to assign the destination variable
        expressionBlock.Add(Expression.Assign(deserializedType, coalesce));
    }
    else
    {
        // for a value type, a "new" instance is created
        expressionBlock.Add(Expression.Assign(deserializedType, Expression.New(type)));
    }

    var thisAsMethodTarget = Expression.Constant(this);

    var methodToCall = typeof(FastDefaultObjectSerializer).GetMethod("DeserializeBase");
    var deserializedTypeAsObject = Expression.TypeAs(deserializedType, typeof(object));

    foreach (var field in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public))
    {
        // access to the field on the instance being deserialized
        var fieldExp = Expression.Field(deserializedType, field);

        var fieldType = Expression.Constant(field.FieldType);

        // a methood call expression
        var call = Expression.Call(
            thisAsMethodTarget,
            methodToCall,
            fieldType,
            deserializedTypeAsObject,
            binaryReaderParameter);

        // the result of the method call is converted to the field type if needed ...
        var callResultAsFieldType = GetExpressionAsTypeIfNeeded(call, field.FieldType);

        // ... and is assigned to the field
        var assignToField = Expression.Assign(fieldExp, callResultAsFieldType);

        expressionBlock.Add(assignToField);
    }

    // the return part of the lambda
    var returnTarget = Expression.Label(typeof(object));
    var returnExpression = Expression.Return(returnTarget, deserializedTypeAsObject, typeof(object));
    var returnLabel = Expression.Label(returnTarget, deserializedTypeAsObject);

    expressionBlock.Add(returnExpression);
    expressionBlock.Add(returnLabel);

    var block = Expression.Block(new ParameterExpression[] { deserializedType }, expressionBlock);

    var lambda = Expression.Lambda<Func<ExtendedBinaryReader, object, object>>(block, binaryReaderParameter, destinationParameter);

    return lambda.Compile();
}

Dans cette méthode, les points clés sont :

  • le test sur le type de l’objet a désérialiser : si il s’agit d’un type valeur, la méthode va le créer, et le retourner. Si non, la méthode utilisera l’instance passée en paramètre.
  • l’appel a la méthode DeserializeBase, afin de s’appuyer sur les mécanismes implémentés précédemment pour la désérialisation
  • la génération d’un bloc de code pour la désérialisation de chaque champ

Cette optimisation a permi de diviser par 3 le temps de serialisation/deserialisation (10000 iterations) d’une classe simple.

Comme toujours, le code est disponible sur github : https://github.com/mathieubrun/Cogimator.Serialization

Utilisation mémoire d’un processus .NET

Lorsque l’on ouvre le gestionnaire des taches Windows, on peut y voir un onglet “Mémoire (jeu de travail privé)” pour chaque processus. Mais que ce cache derrière ce chiffre ? Afin de le savoir, je vais vous présenter l’outil VMMap, de Sysinternals, disponible au téléchargement ici : http://technet.microsoft.com/en-us/sysinternals/dd535533.aspx

Cet outil va vous présenter trois graphes de mémoires :

  • Commited : représente la quantité qu’occuperaient tout le code et données de l’application, ainsi que les fichiers mappés par celle ci.
  • Private Bytes : représente la quantité de mémoire demandée par le processus, et ne pouvant être partagée avec d’autres processus. Cette mémoire peut se trouver sur un fichier d'échange.
  • Working Set : représente la mémoire physique utilisée par le processus, c’est à dire qu’aucun accès au fichier d’echange ne sera fait lors d’un accès à cette mémoire.

Ces trois graphes sont subdivisés en différentes catégories. Typiquement, les catégories sur lesquelles le développeur pourra avoir un impact sont :

  • Image : représente les librairies chargées par l'application.
  • Managed Heap : représente les tas alloués par la CLR .Net. Une augmentation incontrôlée de cette valeur peut indiquer une fuite mémoire.
  • Private : représente la mémoire non allouée par la CLR .Net. Par exemple,  les données d'une image chargée au travers de Bitmap.FromFile seront dans cette zone mémoire.

Voici quatre captures d'écran de l’outil VMMap,  représentant quatre états de la mémoire pour une application simple.

Après le chargement de l'application :

image

On peut constater que la mémoire “Managed Heap” ainsi que “Private Data” sont respectivement de 2.3 et 25 Mo.

Après création de 10 tableaux de 1000000 bytes (non initialisés) :

image

La partie “Managed Heap” dans “Private Bytes” est maintenant de 109 Mo. Il s’agit uniquement de mémoire réservée, et non de mémoire utilisée ! C’est bien pour cela que le “Managed Heap” dans le “Working Set” est toujours de 2.5Mo.

Après l'initialisation de ces tableaux :

image

Cette fois ci, la taille du “Managed Heap” dans le “Working Set” a augmenté de manière significative : 108 Mo.

Après chargement de 300 images png de 40Ko.

image

Les données des images ont été allouées dans “Private data”, car System.Drawing.Bitmap utilise du code non managé.

Enfin, pour suivre la consommation mémoire d’une application, on pourra se baser sur les compteurs de performance suivants :

image

Implémentation naive d'un Serializer en C# - Partie 6

Une des dernières parties de cette série d’article concerne la sérialisation correcte des graphes d’objets, et surtout de leurs références. En effet, le tableau déclaré dé la manière suivante :

var instance = new TestReference() { Str = "3" };
var array = new TestReference[] { instance, instance, instance, instance };

Ne doit pas sérialiser l’objet “Instance” quatre fois, mais une seule. La résolution de ce problème permettra également d’aborder les références cycliques :

var t1 = new TestReference() { Str = "1" };
var t2 = new TestReference() { Str = "2" };

t1.Reference = t2;
t2.Reference = t1;

Dans un premier temps, il faut pouvoir identifier les objets de manière unique. Dans un premier temps, j’ai régardé du coté de la classe GCHandlepour obtenir l’adresse mémoire des objets. Cette méthode ne s’est pas avérée adaptée : le Garbage Collector pouvant déplacer les objets et donc changer leur adresse mémoire.

En fait, le framework offre une classe toute faite pour identifier les objets : ObjectIDGenerator, qui permet d’obtenir un identifiant unique pour chaque objet passé en paramètre à la méthode GetId. Et en bonus, cette méthode indique même si il s’agit d’une instance déjà identifiée.

La modification de la classe DefaultObjectSerializer s’avère donc simple :

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    bool firstTime;

    // generate unique id for object, in order not to save same object multiple times
    var key = idGenerator.GetId(source, out firstTime);

    writer.Write(firstTime);
    writer.Write(key);

    if (firstTime)
    {
        // inspect object
        foreach (var prop in sourceType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).OrderBy(x => x.Name))
        {
            this.SerializeBase(prop.FieldType, prop.GetValue(source), writer);
        }
    }
}

public override object Deserialize(ExtendedBinaryReader source, object target, Type type)
{
    var firstTime = source.ReadBoolean();
    var key = source.ReadInt64();

    if (!firstTime)
    {
        return cache[key];
    }
    else
    {
        var destination = Activator.CreateInstance(type);

        // add instance to cache before deserializing properties, to untangle eventual cyclic dependencies
        cache.Add(key, destination);

        // inspect object
        foreach (var prop in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).OrderBy(x => x.Name))
        {
            var v = this.DeserializeBase(prop.FieldType, destination, source);
            prop.SetValue(destination, v);
        }

        return destination;
    }
}

En résumé, pour la sérialisation, on identifie chaque objet sérialisé, et si il est connu, on ne sérialise que son identifiant. Pour la désérialisation, on place les objets et leur identifiant dans un dictionnaire faisant office de cache.

La subtilité concerne les références cycliques : il faut placer l’objet dans le cache juste après sa création, car lorsque l’on va désérialiser les propriétés de l’objet, on pourrait rencontrer une référence vers un objet que l’on n’aurait pas encore désérialisé.

Comme toujours, les tests unitaires permettent de valider que les modifications n’entrainent pas de régressions.

Implémentation naive d'un Serializer en C# - Partie 5

Après avoir refactorisé le code du Serializer, j'ai choisi d'implémenter la sérialisation des implémentations d'interfaces. En effet, si un objet possède des propriétés de type interface (IList<T> par exemple), ce n'est pas pour autant qu'il ne doit pas pouvoir être sérialisable.

L'implémentation de la classe InterfaceSerializer s'est avérée plus simple que prévue : dans le principe, si un type de propriété est une interface, et que la valeur de cette propriété est non nulle, le type de la valeur (via GetType()) est sérialisé.

Ensuite, on appelle simplement le sérializer racine, en lui substituant le type de l'interface par le type de l'instance qui l'implémente.

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    var st = source.GetType();

    // write implemented type
    writer.Write(st);

    // continue with implemented type and not interface
    base.Serialize(writer, source, st);
}

Implémentation naive d'un Serializer en C# - Partie 4

Après avoir implémenté le support de la sérialisation des tableaux,  le code est devenu moins lisible. En effet, toute la logique pour le choix du type d'objet à sérialiser se faisait dans une seule méthode,  bardée de ifs. Le but de cette implémentation étant de m'amuser, je ne pouvais laisser cette situation perdurer.

Pour simplifier le code, j'ai choisi d'implémenter une interface ISubSerializer plus spécialisée. Le principe est simple, chaque implémentation de ISubSerializer est applicable pour un type d'objet donné, et sait comment le sérialiser/déserialiser. Ces instances sont organisées de manière hiérarchique, chacune pouvant avoir des ISubSerializer enfant.

public interface ISubSerializer
{
    bool CanApply(Type type);
    void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType);
    object Deserialize(ExtendedBinaryReader source, object target, Type type);
}

Le serializer racine, quant à lui, se charge d'appeler le ISubSerializer adéquat, en fonction du type d'objet à sérialiser.

public void SerializeBase(Type sourceType, object source, ExtendedBinaryWriter writer)
{
    var serializers = this.SubSerializers ?? this.Root.SubSerializers;

    foreach (var s in serializers)
    {
        if (s.CanApply(sourceType))
        {
            s.Serialize(writer, source, sourceType);
            return;
        }
    }
}

Par exemple, dans le cas des types nullables, la class ObjectSerializer se charge uniquement de sérialiser un boolean indiquant si l'objet est null ou non.

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    // always write a boolean indicating if object is null or not
    var hasValue = source != null;
    writer.Write(hasValue);

    if (hasValue)
    {
        this.SerializeBase(sourceType, source, writer);
    }
}

Ensuite, la classe NullableSerializer va appeler le serializer racine pour sérialiser le type valeur sous-jacent.

public override void Serialize(ExtendedBinaryWriter writer, object source, Type sourceType)
{
    this.SerializeBase(sourceType.GetGenericArguments().First(), source, writer);
}

De cette manière,  ajouter le support pour de nouveaux types devient l'affaire d'implémenter un nouveau ISubSerializer et de le déclarer dans le serializer racine.

Le code source est disponible sur GitHub : https://github.com/mathieubrun/Cogimator.Serialization/blob/master/Cogimator.Serialization/

Implémentation naive d'un Serializer en C# - Partie 3

Cette semaine, l'itération suivante de notre serializer supporte les tableaux d'objets.

Avec la propriété Array.Rank ainsi que la méthode Array.GetLength(int), je peux déterminer le nombre de dimensions du tableau, ainsi que la taille de celles-ci. Ces valeurs seront sérialisées dans le flux binaire pour reconstruire le tableau lors de la désérialisation.

La méthode Array.GetValue(int[]) permet de récupérer la valeur dans le tableau en fonction des indices passés en paramètre. Le calcul de tous les indices se fait en deux étapes. Dans un premier temps, il faut déterminer les indices possibles pour chaque dimension du tableau, en fonction de sa longueur. Ensuite, il reste à calculer le produit cartésien de tous ces indices. Cet ensemble servira à sérialiser l'ensemble des valeurs du tableau.

La désérialisation est simplement le procédé inverse.

Le code source est disponible sur GitHub : https://github.com/mathieubrun/Cogimator.Serialization/blob/master/Cogimator.Serialization/ReflectionSerializer.cs

Implémentation naive d'un Serializer en C# - Partie 2

Pour la suite de cette série, je vais vous présenter le fonctionnement de la 1ere itération du serializer. Cette version supporte les types de base, nullables ou non, ainsi que les graphes d'objets simples (pas de cycles, pas de tableaux).

Dans un premier temps, le serializer va détecter le type de l'objet passé en paramètre. Si il s'agit d'un type valeur standard, celui ci est écrit dans le flux.

Si il s'agit d'un objet, celui ci sera inspecté. Cette inspection servira a déterminer si il s'agit d'un Nullable, ou d'un autre type d'objet. Dans les deux cas, on écrira dans le flux un booléen indiquant si l'objet est null.

L'écriture dans le flux se fait au travers de la classe BinaryWriter, étendue pour gérer les cas spécifiques. La classe BinaryWriter de base ne supportant les chaines nulles, la méthode Write(string) est surchargée pour gérer ce cas.

La désérialisation suit le même principe, le flux d'octets est lu à l'aide d'une implémentation spécifique de la classe BinaryReader, et l'objet est reconstitué.

Le code source est disponible sur GitHub : https://github.com/mathieubrun/Cogimator.Serialization/blob/master/Cogimator.Serialization/ReflectionSerializer.cs

Implémentation naive d'un Serializer en C# - Partie 1

Cet article sera le premier d'une série qui me démangeait depuis quelque temps, sur l'implémentation d'un serializer en C#. Le but de cette implémentation n'est pas de rivaliser avec un protobuf-net, mais plutôt l'occasion d'écrire un peu de code plus bas niveau que d'habitude.

Pour commencer, le but est d'obtenir le même niveau de fonctionnalité que le BinaryFormatter du Framework. Voilà pour nos spécifications fonctionnelles détaillées !

Au niveau de l'implémentation, j'ai choisi de commencer par une approche naïve basée sur la reflection. Cette première étape permettra la mise en place des tests unitaires automatisés servant à vérifier le bon fonctionnement du Serializer.

Ce bon fonctionnement s'appuie sur deux phases : durant la sérialisation, notre objet est transformé en tableau d'octets. Durant la désérialisation, ce même tableau d'octets sert à recomposer notre objet. Il faut dont choisir un format de stockage pour les différentes données présentes. J'ai choisi de rester le plus simple possible : les membres des notre objet sont sérialisés dans l'ordre alphabétique. 

Ceci a pour implication, tout comme le BinaryFormatter, de ne permettre de désérialiser uniquement dans le même objet: si des définitions de champs sont modifiées, le processus ne fonctionnera plus.

Les champs de notre objet étant sérialisés dans l'ordre alphabétiques, dans un premier temps les champs de type valeur sont convertis en tableau d'octets et placés les uns a la suite des autres. Pour les string, les octets représentant la chaîne seront précédés de la longueur de celle ci.

Pour les autres types de champs (object, nullables, ...) ce sera l'objet de l'article suivant.