Comment puis-je sérialiser efficacement les structures Go sur le disque avec une taille de fichier minimale ?

Sérialisation Go efficace de la structure sur disque : atteindre un gonflement minimal

Malgré la sortie gonflée produite par la sérialisation gob, une analyse plus approfondie révèle que les résultats ultérieurs les entrées du même type n'entraînent qu'une surcharge de 12 octets. Cette surcharge représente la taille minimale requise pour coder deux chaînes d'une longueur de 4 octets (y compris les préfixes de longueur).

Pour réduire la taille globale du fichier, envisagez les stratégies suivantes :

• Utiliser plusieurs instances d'encodeurs : L'amortissement du coût de compilation du codec personnalisé sur plusieurs encodeurs peut réduire considérablement les frais généraux du premier. entrée.
• Compresser la sortie : L'utilisation de bibliothèques de compression telles que compress/flate ou bzip2 peut réduire davantage la taille du fichier, bzip2 atteignant la plus grande efficacité dans le test fourni (2,04 octets/entrée). .

Démonstration de code :

Le Go suivant le code illustre les différentes approches discutées :

package main

import (
    "bytes"
    "compress/bzip2"
    "compress/flate"
    "compress/gzip"
    "compress/zlib"
    "encoding/gob"
    "fmt"
    "io"
)

type Entry struct {
    Key string
    Val string
}

func main() {
    // Create test data
    entries := make([]Entry, 1000)
    for i := 0; i < 1000; i++ {
        entries[i].Key = fmt.Sprintf("k%03d", i)
        entries[i].Val = fmt.Sprintf("v%03d", i)
    }

    // Test different encoding/compression techniques
    for _, name := range []string{"Naked", "flate", "zlib", "gzip", "bzip2"} {
        buf := &bytes.Buffer{}

        var out io.Writer
        switch name {
        case "Naked":
            out = buf
        case "flate":
            out, _ = flate.NewWriter(buf, flate.DefaultCompression)
        case "zlib":
            out, _ = zlib.NewWriterLevel(buf, zlib.DefaultCompression)
        case "gzip":
            out = gzip.NewWriter(buf)
        case "bzip2":
            out, _ = bzip2.NewWriter(buf, nil)
        }

        enc := gob.NewEncoder(out)
        for _, e := range entries {
            enc.Encode(e)
        }

        if c, ok := out.(io.Closer); ok {
            c.Close()
        }
        fmt.Printf("[%5s] Length: %5d, average: %5.2f / Entry\n",
            name, buf.Len(), float64(buf.Len())/1000)
    }
}

Sortie :

[Naked] Length: 16053, average: 16.05 / Entry
[flate] Length:  3988, average:  3.99 / Entry
[ zlib] Length:  3994, average:  3.99 / Entry
[ gzip] Length:  4006, average:  4.01 / Entry
[bzip2] Length:  1977, average:  1.98 / Entry

Comme le montre le résultat, l'utilisation de techniques de compression réduit considérablement la taille du fichier, avec bzip2 atteignant un impressionnant 1,98 octets/entrée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!