Rapide de sérialisation/désérialisation des structs

J'ai d'énormes amont de données géographiques représentées dans simple la structure de l'objet composé uniquement des structures. Tous mes champs sont de type valeur.

public struct Child
{
   readonly float X;
   readonly float Y;
   readonly int myField;
}

public struct Parent
{
   readonly int id;
   readonly int field1;
   readonly int field2;
   readonly Child[] children;
}

Les données sont découpées en place bien à de petites portions de Parent[]-s. Chaque tableau contient quelques milliers Parent instances. J'ai beaucoup trop de données pour garder tout en mémoire, donc j'ai besoin de swap de ces morceaux sur le disque d'avant en arrière. (Un fichier de résultat env. 2-300 KO).

Quel serait le moyen le plus efficace de la sérialisation/désérialisation du Parent[] à un byte[] pour dumpint à disque et de la lecture? Concernant la vitesse, je suis particulièrement intéressé par rapide de la désérialisation, la vitesse d'écriture n'est pas que critique.

Serait simple BinarySerializer assez bon?
Ou devrais-je pirater autour avec StructLayout (voir accepté de répondre)? Je ne suis pas sûr si cela fonctionnerait avec le tableau champ de Parent.children.

Mise à JOUR: Réponse aux commentaires - Oui, les objets sont immuables (code mis à jour) et en effet le children champ n'est pas le type de valeur. 300KB ne semble pas beaucoup, mais j'ai des milliards de fichiers comme ça, si la vitesse est importante.

Tous mes champs sont de type valeur - Le children champ n'est pas un type de valeur.
300KB est en petite quantité, ce montant est désérialisé/sérialisé en 0,1 s w/o optimisations
Est toutes vos données en lecture seule?
Le binaire sérialiseur est très lent. Il utilise la réflexion pour injecter des métadonnées dans la sérialisation des données. Car il ne fournit pas de type de métadonnées, XML sérialiseur sérialise les données dans un format plus petit et plus rapide format que le binaire sérialiseur. Dans les deux cas, la sérialisation est faite par l'intermédiaire de la réflexion et est très lent. Un de mes brillants collègues créé un mécanisme de sérialisation binaire qui est 20 fois plus rapide que le sérialiseur XML, qui a été plus rapide que le binaire sérialiseur. Il a été aussi considérablement plus petites.

OriginalL'auteur user256890 | 2012-03-30

  1. 10

    BinarySerializer est très générale sérialiseur. Il ne sera pas exécuter ainsi que d'une implémentation personnalisée.

    Heureusement pour votre, vos données se compose de structures. Cela signifie que vous serez en mesure de fixer un structlayout à l'Enfant et à juste bit-copier les enfants tableau à l'aide de code non sécurisé à partir d'un byte[] vous avez lu à partir du disque.

    Pour les parents, il n'est pas si facile parce que vous avez besoin pour traiter les enfants séparément. Je vous recommande d'utiliser le code unsafe pour copier les bits copiable champs du byte[] vous lire et désérialiser les enfants séparément.

    Avez-vous pensé à la cartographie de tous les enfants dans la mémoire en utilisant les fichiers mappés en mémoire? Vous pouvez ré-utiliser les systèmes d'exploitation cache et pas face à la lecture et à l'écriture.

    Zéro-copie-la désérialisation d'un Enfant[] ressemble à ceci:

    byte[] bytes = GetFromDisk();
fixed (byte* bytePtr = bytes) {
 Child* childPtr = (Child*)bytePtr;
 //now treat the childPtr as an array:
 var x123 = childPtr[123].X;

 //if we need a real array that can be passed around, we need to copy:
 var childArray = new Child[GetLengthOfDeserializedData()];
 for (i = [0..length]) {
  childArray[i] = childPtr[i];
 }
}
    J'ai regardé les fichiers mappés en mémoire, ils ont fière allure pour accéder au disque dur de la gestion! Pourriez-vous écrire un exemple pour la dangereuse segment? Comment puis-je "jette" un byte[] pour un Enfant[] en mode non sécurisé? Parce que comme vous l'avez dit qu'il prendrait le temps zéro.
    J'ai ajouté un exemple. Si vous voulez zéro-copie vous avez besoin de modifier votre application pour utiliser des pointeurs ou dangereux IO à l'aide de ReadFile (lire directement dans un Enfant[]). Mais ma conjecture est que le seul passage de la copie est vraiment rien. Les processeurs sont bons.

    OriginalL'auteur usr

  2. 10

    Si vous n'avez pas envie d'aller en bas de la écrire votre propre sérialiseur itinéraire, vous pouvez utiliser le protobuf.net sérialiseur. Voici la sortie d'un petit programme de test:

    Using 3000 parents, each with 5 children
BinaryFormatter Serialized in: 00:00:00.1250000
Memory stream 486218 B
BinaryFormatter Deserialized in: 00:00:00.1718750

ProfoBuf Serialized in: 00:00:00.1406250
Memory stream 318247 B
ProfoBuf Deserialized in: 00:00:00.0312500

    Il devrait être assez explicite. C'était juste pour une seule course, mais est assez révélateur de la vitesse, j'ai vu (3-5x).

    Pour faire de votre structs serializable (avec protobuf.net), il suffit d'ajouter les attributs suivants:

    [ProtoContract]
[Serializable]
public struct Child
{
    [ProtoMember(1)] public float X;
    [ProtoMember(2)] public float Y;
    [ProtoMember(3)] public int myField;
}

[ProtoContract]
[Serializable]
public struct Parent
{
    [ProtoMember(1)] public int id;
    [ProtoMember(2)] public int field1;
    [ProtoMember(3)] public int field2;
    [ProtoMember(4)] public Child[] children;
}

    Mise à JOUR:

    En fait, l'écriture d'un personnalisé sérialiseur est assez simple, voici un bare-bones de mise en œuvre:

    class CustSerializer
{
public void Serialize(Stream stream, Parent[] parents, int childCount)
{
BinaryWriter sw = new BinaryWriter(stream);
foreach (var parent in parents)
{
sw.Write(parent.id);
sw.Write(parent.field1);
sw.Write(parent.field2);
foreach (var child in parent.children)
{
sw.Write(child.myField);
sw.Write(child.X);
sw.Write(child.Y);
}
}
}
public Parent[] Deserialize(Stream stream, int parentCount, int childCount)
{
BinaryReader br = new BinaryReader(stream);
Parent[] parents = new Parent[parentCount];
for (int i = 0; i < parentCount; i++)
{
var parent = new Parent();
parent.id = br.ReadInt32();
parent.field1 = br.ReadInt32();
parent.field2 = br.ReadInt32();
parent.children = new Child[childCount];
for (int j = 0; j < childCount; j++)
{
var child = new Child();
child.myField = br.ReadInt32();
child.X = br.ReadSingle();
child.Y = br.ReadSingle();
parent.children[j] = child;
}
parents[i] = parent;
}
return parents;
}
}

    Et voici sa sortie lorsqu'il est exécuté dans un simple test de vitesse:

    Custom Serialized in: 00:00:00 
Memory stream 216000 B 
Custom Deserialized in: 00:00:00.0156250

    Évidemment, c'est beaucoup moins souple que les autres approches, mais si la vitesse est vraiment important c'est environ 2-3x plus rapide que le protobuf méthode. Il produit des minimes tailles de fichier, donc l'écriture sur le disque devrait être plus rapide.

    Protobuf est un excellent compromis entre la facilité d'utilisation et de performances dans la plupart des cas. Si vous voulez aller de noix-il toujours ne pouvez pas battre la performance d'une solution personnalisée. Surtout un peu-blittable un qui peut avoir un coût de zéro!

    OriginalL'auteur markmuetz