Come ottenere la dimensione di struct e il suo contenuto in byte in golang?

Question

ho una struct, dicono:

type ASDF struct { 
    A uint64 
    B uint64 
    C uint64 
    D uint64 
    E uint64 
    F string 
} 

creo una fetta di quel struct: a := []ASDF{}

faccio operazioni su quella fetta del struct (struct aggiunta/rimozione/aggiornamento che variano nei contenuti) ; come posso ottenere la dimensione totale in byte (per memoria) della sezione e del suo contenuto? C'è un built-in per fare questo o ho bisogno di eseguire manualmente un calcolo utilizzando unsafe.Sizeof e quindi len ogni stringa?

Answer 1

Somma la dimensione di tutta la memoria, escluso il garbage collector e altro overhead. Ad esempio,

package main 

import (
    "fmt" 
    "unsafe" 
) 

type ASDF struct { 
    A uint64 
    B uint64 
    C uint64 
    D uint64 
    E uint64 
    F string 
} 

func (s *ASDF) size() int { 
    size := int(unsafe.Sizeof(*s)) 
    size += len(s.F) 
    return size 
} 

func sizeASDF(s []ASDF) int { 
    size := 0 
    s = s[:cap(s)] 
    size += cap(s) * int(unsafe.Sizeof(s)) 
    for i := range s { 
     size += (&s[i]).size() 
    } 
    return size 
} 

func main() { 
    a := []ASDF{} 

    b := ASDF{} 
    b.A = 1 
    b.B = 2 
    b.C = 3 
    b.D = 4 
    b.E = 5 
    b.F = "ASrtertetetetetetetDF" 
    fmt.Println((&b).size()) 
    a = append(a, b) 

    c := ASDF{} 
    c.A = 10 
    c.B = 20 
    c.C = 30 
    c.D = 40 
    c.E = 50 
    c.F = "ASetDF" 
    fmt.Println((&c).size()) 
    a = append(a, c) 

    fmt.Println(len(a)) 
    fmt.Println(cap(a)) 
    fmt.Println(sizeASDF(a)) 
} 

uscita:

69 
54 
2 
2 
147 

http://play.golang.org/p/5z30vkyuNM

Answer 2

Ho paura di dire che unsafe.Sizeof è il modo di andare qui se si vuole ottenere alcun risultato. La dimensione in memoria di una struttura è nulla su cui dovresti fare affidamento. Si noti che anche il risultato di unsafe.Sizeof non è accurato: il runtime può aggiungere intestazioni ai dati che non è possibile osservare per agevolare la garbage collection.

Per il tuo esempio particolare (trovare una dimensione della cache) ti suggerisco di andare con una dimensione statica che è ragionevole per molti processori. In quasi tutti i casi fare micro ottimizzazioni non si ripaga da sé.