...
Run Format

Source file src/encoding/json/bench_test.go

Documentation: encoding/json

  // Copyright 2011 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // Large data benchmark.
  // The JSON data is a summary of agl's changes in the
  // go, webkit, and chromium open source projects.
  // We benchmark converting between the JSON form
  // and in-memory data structures.
  
  package json
  
  import (
  	"bytes"
  	"compress/gzip"
  	"io/ioutil"
  	"os"
  	"strings"
  	"testing"
  )
  
  type codeResponse struct {
  	Tree     *codeNode `json:"tree"`
  	Username string    `json:"username"`
  }
  
  type codeNode struct {
  	Name     string      `json:"name"`
  	Kids     []*codeNode `json:"kids"`
  	CLWeight float64     `json:"cl_weight"`
  	Touches  int         `json:"touches"`
  	MinT     int64       `json:"min_t"`
  	MaxT     int64       `json:"max_t"`
  	MeanT    int64       `json:"mean_t"`
  }
  
  var codeJSON []byte
  var codeStruct codeResponse
  
  func codeInit() {
  	f, err := os.Open("testdata/code.json.gz")
  	if err != nil {
  		panic(err)
  	}
  	defer f.Close()
  	gz, err := gzip.NewReader(f)
  	if err != nil {
  		panic(err)
  	}
  	data, err := ioutil.ReadAll(gz)
  	if err != nil {
  		panic(err)
  	}
  
  	codeJSON = data
  
  	if err := Unmarshal(codeJSON, &codeStruct); err != nil {
  		panic("unmarshal code.json: " + err.Error())
  	}
  
  	if data, err = Marshal(&codeStruct); err != nil {
  		panic("marshal code.json: " + err.Error())
  	}
  
  	if !bytes.Equal(data, codeJSON) {
  		println("different lengths", len(data), len(codeJSON))
  		for i := 0; i < len(data) && i < len(codeJSON); i++ {
  			if data[i] != codeJSON[i] {
  				println("re-marshal: changed at byte", i)
  				println("orig: ", string(codeJSON[i-10:i+10]))
  				println("new: ", string(data[i-10:i+10]))
  				break
  			}
  		}
  		panic("re-marshal code.json: different result")
  	}
  }
  
  func BenchmarkCodeEncoder(b *testing.B) {
  	if codeJSON == nil {
  		b.StopTimer()
  		codeInit()
  		b.StartTimer()
  	}
  	b.RunParallel(func(pb *testing.PB) {
  		enc := NewEncoder(ioutil.Discard)
  		for pb.Next() {
  			if err := enc.Encode(&codeStruct); err != nil {
  				b.Fatal("Encode:", err)
  			}
  		}
  	})
  	b.SetBytes(int64(len(codeJSON)))
  }
  
  func BenchmarkCodeMarshal(b *testing.B) {
  	if codeJSON == nil {
  		b.StopTimer()
  		codeInit()
  		b.StartTimer()
  	}
  	b.RunParallel(func(pb *testing.PB) {
  		for pb.Next() {
  			if _, err := Marshal(&codeStruct); err != nil {
  				b.Fatal("Marshal:", err)
  			}
  		}
  	})
  	b.SetBytes(int64(len(codeJSON)))
  }
  
  func BenchmarkCodeDecoder(b *testing.B) {
  	if codeJSON == nil {
  		b.StopTimer()
  		codeInit()
  		b.StartTimer()
  	}
  	b.RunParallel(func(pb *testing.PB) {
  		var buf bytes.Buffer
  		dec := NewDecoder(&buf)
  		var r codeResponse
  		for pb.Next() {
  			buf.Write(codeJSON)
  			// hide EOF
  			buf.WriteByte('\n')
  			buf.WriteByte('\n')
  			buf.WriteByte('\n')
  			if err := dec.Decode(&r); err != nil {
  				b.Fatal("Decode:", err)
  			}
  		}
  	})
  	b.SetBytes(int64(len(codeJSON)))
  }
  
  func BenchmarkDecoderStream(b *testing.B) {
  	b.StopTimer()
  	var buf bytes.Buffer
  	dec := NewDecoder(&buf)
  	buf.WriteString(`"` + strings.Repeat("x", 1000000) + `"` + "\n\n\n")
  	var x interface{}
  	if err := dec.Decode(&x); err != nil {
  		b.Fatal("Decode:", err)
  	}
  	ones := strings.Repeat(" 1\n", 300000) + "\n\n\n"
  	b.StartTimer()
  	for i := 0; i < b.N; i++ {
  		if i%300000 == 0 {
  			buf.WriteString(ones)
  		}
  		x = nil
  		if err := dec.Decode(&x); err != nil || x != 1.0 {
  			b.Fatalf("Decode: %v after %d", err, i)
  		}
  	}
  }
  
  func BenchmarkCodeUnmarshal(b *testing.B) {
  	if codeJSON == nil {
  		b.StopTimer()
  		codeInit()
  		b.StartTimer()
  	}
  	b.RunParallel(func(pb *testing.PB) {
  		for pb.Next() {
  			var r codeResponse
  			if err := Unmarshal(codeJSON, &r); err != nil {
  				b.Fatal("Unmarshal:", err)
  			}
  		}
  	})
  	b.SetBytes(int64(len(codeJSON)))
  }
  
  func BenchmarkCodeUnmarshalReuse(b *testing.B) {
  	if codeJSON == nil {
  		b.StopTimer()
  		codeInit()
  		b.StartTimer()
  	}
  	b.RunParallel(func(pb *testing.PB) {
  		var r codeResponse
  		for pb.Next() {
  			if err := Unmarshal(codeJSON, &r); err != nil {
  				b.Fatal("Unmarshal:", err)
  			}
  		}
  	})
  	// TODO(bcmills): Is there a missing b.SetBytes here?
  }
  
  func BenchmarkUnmarshalString(b *testing.B) {
  	data := []byte(`"hello, world"`)
  	b.RunParallel(func(pb *testing.PB) {
  		var s string
  		for pb.Next() {
  			if err := Unmarshal(data, &s); err != nil {
  				b.Fatal("Unmarshal:", err)
  			}
  		}
  	})
  }
  
  func BenchmarkUnmarshalFloat64(b *testing.B) {
  	data := []byte(`3.14`)
  	b.RunParallel(func(pb *testing.PB) {
  		var f float64
  		for pb.Next() {
  			if err := Unmarshal(data, &f); err != nil {
  				b.Fatal("Unmarshal:", err)
  			}
  		}
  	})
  }
  
  func BenchmarkUnmarshalInt64(b *testing.B) {
  	data := []byte(`3`)
  	b.RunParallel(func(pb *testing.PB) {
  		var x int64
  		for pb.Next() {
  			if err := Unmarshal(data, &x); err != nil {
  				b.Fatal("Unmarshal:", err)
  			}
  		}
  	})
  }
  
  func BenchmarkIssue10335(b *testing.B) {
  	b.ReportAllocs()
  	j := []byte(`{"a":{ }}`)
  	b.RunParallel(func(pb *testing.PB) {
  		var s struct{}
  		for pb.Next() {
  			if err := Unmarshal(j, &s); err != nil {
  				b.Fatal(err)
  			}
  		}
  	})
  }
  
  func BenchmarkUnmapped(b *testing.B) {
  	b.ReportAllocs()
  	j := []byte(`{"s": "hello", "y": 2, "o": {"x": 0}, "a": [1, 99, {"x": 1}]}`)
  	b.RunParallel(func(pb *testing.PB) {
  		var s struct{}
  		for pb.Next() {
  			if err := Unmarshal(j, &s); err != nil {
  				b.Fatal(err)
  			}
  		}
  	})
  }
  

View as plain text