Go: json codage struct avec des pointeurs est plus lent qu'avec des copies?

Question

je le code de test suivant:

package main 

import (
    "fmt" 
    "testing" 
    "encoding/json" 
) 

type Coll1 struct { 
    A string 
    B string 
    C string 
} 

type Coll2 struct { 
    A *string 
    B *string 
    C *string 
} 

var as = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 
var bs = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" 
var cs = "ccccccccccccccccccccccccccccccccc" 

func testBM1(b *testing.B) { 
    for i := 0; i<b.N; i++ { 
     json.Marshal(Coll1{as,bs,cs}) 
    } 
} 

func testBM2(b *testing.B) { 
    for i := 0; i<b.N; i++ { 
     json.Marshal(Coll2{&as,&bs,&cs}) 
    } 
} 

func main() { 
    fmt.Println(testing.Benchmark(testBM1)) 
    fmt.Println(testing.Benchmark(testBM2)) 
} 

je me attends le second cas, de courir plus vite, car il utilise des pointeurs et ne dispose donc pas de copier les chaînes, mais en fait, il fonctionne à environ 4250 ns/op où la première tourne près de 2800 ns/op. Quelqu'un peut-il faire la lumière sur pourquoi cela pourrait être? Edit: Darshan Computing a suggéré que cela pourrait même être vrai pour les structures intégrées. Un simple test confirme:

package main 

import (
    "fmt" 
    "testing"     
    "encoding/json"    
) 

type Coll1 struct { 
    A,B,C string 
} 

type Coll1Outer struct { 
    A,B,C Coll1 
} 

type Coll2Outer struct { 
    A,B,C *Coll2 
} 

type Coll2 struct { 
    A,B,C *string 
} 

var as = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 
var bs = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" 
var cs = "ccccccccccccccccccccccccccccccccc" 

func testBM1(b *testing.B) { 
    for i := 0; i<b.N; i++ { 
     c := Coll1Outer{ Coll1{as,bs,cs}, 
         Coll1{as,bs,cs},     
         Coll1{as,bs,cs} }    
     json.Marshal(c) 
    } 
} 

func testBM2(b *testing.B) { 
    for i := 0; i<b.N; i++ { 
     c := Coll2Outer{ &Coll2{&as,&bs,&cs}, 
         &Coll2{&as,&bs,&cs},    
         &Coll2{&as,&bs,&cs} }   
     json.Marshal(c) 
    } 
} 

func main() { 
    fmt.Println(testing.Benchmark(testBM1)) 
    fmt.Println(testing.Benchmark(testBM2)) 
} 

Pour moi, cela montre la struct non-pointeur prenant environ 12ms/op, tandis que celui des pointeurs prend 13ms/op. Pas une énorme différence, mais c'est intéressant que la propriété tient toujours.

Answer 1

je remarque la plus grande différence de pourcentage ns/op quand je mis as, bs et cs-"a", "b" et "c", respectivement. Au fur et à mesure que j'augmente la longueur des cordes, elles se rapprochent l'une de l'autre. Ils semblent toujours être environ 1000 ns/op différents.

Donc, je crois que tout ce qui se passe est que cela prend 1000 ns sur ma machine (1450 sur le vôtre) pour refléter et suivre les pointeurs. Le passage d'une structure plus petite à l'avant ne semble pas contrecarrer cet effet car une fois que les pointeurs sont suivis, Marshal passe toujours les données en interne lors du processus de génération et de retour du JSON équivalent.