bench_test.go

Documentation: encoding/json

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Large data benchmark.
     6  // The JSON data is a summary of agl's changes in the
     7  // go, webkit, and chromium open source projects.
     8  // We benchmark converting between the JSON form
     9  // and in-memory data structures.
    10  
    11  package json
    12  
    13  import (
    14  	"bytes"
    15  	"compress/gzip"
    16  	"fmt"
    17  	"internal/testenv"
    18  	"io"
    19  	"os"
    20  	"reflect"
    21  	"runtime"
    22  	"strings"
    23  	"sync"
    24  	"testing"
    25  )
    26  
    27  type codeResponse struct {
    28  	Tree     *codeNode `json:"tree"`
    29  	Username string    `json:"username"`
    30  }
    31  
    32  type codeNode struct {
    33  	Name     string      `json:"name"`
    34  	Kids     []*codeNode `json:"kids"`
    35  	CLWeight float64     `json:"cl_weight"`
    36  	Touches  int         `json:"touches"`
    37  	MinT     int64       `json:"min_t"`
    38  	MaxT     int64       `json:"max_t"`
    39  	MeanT    int64       `json:"mean_t"`
    40  }
    41  
    42  var codeJSON []byte
    43  var codeStruct codeResponse
    44  
    45  func codeInit() {
    46  	f, err := os.Open("testdata/code.json.gz")
    47  	if err != nil {
    48  		panic(err)
    49  	}
    50  	defer f.Close()
    51  	gz, err := gzip.NewReader(f)
    52  	if err != nil {
    53  		panic(err)
    54  	}
    55  	data, err := io.ReadAll(gz)
    56  	if err != nil {
    57  		panic(err)
    58  	}
    59  
    60  	codeJSON = data
    61  
    62  	if err := Unmarshal(codeJSON, &codeStruct); err != nil {
    63  		panic("unmarshal code.json: " + err.Error())
    64  	}
    65  
    66  	if data, err = Marshal(&codeStruct); err != nil {
    67  		panic("marshal code.json: " + err.Error())
    68  	}
    69  
    70  	if !bytes.Equal(data, codeJSON) {
    71  		println("different lengths", len(data), len(codeJSON))
    72  		for i := 0; i < len(data) && i < len(codeJSON); i++ {
    73  			if data[i] != codeJSON[i] {
    74  				println("re-marshal: changed at byte", i)
    75  				println("orig: ", string(codeJSON[i-10:i+10]))
    76  				println("new: ", string(data[i-10:i+10]))
    77  				break
    78  			}
    79  		}
    80  		panic("re-marshal code.json: different result")
    81  	}
    82  }
    83  
    84  func BenchmarkCodeEncoder(b *testing.B) {
    85  	b.ReportAllocs()
    86  	if codeJSON == nil {
    87  		b.StopTimer()
    88  		codeInit()
    89  		b.StartTimer()
    90  	}
    91  	b.RunParallel(func(pb *testing.PB) {
    92  		enc := NewEncoder(io.Discard)
    93  		for pb.Next() {
    94  			if err := enc.Encode(&codeStruct); err != nil {
    95  				b.Fatal("Encode:", err)
    96  			}
    97  		}
    98  	})
    99  	b.SetBytes(int64(len(codeJSON)))
   100  }
   101  
   102  func BenchmarkCodeMarshal(b *testing.B) {
   103  	b.ReportAllocs()
   104  	if codeJSON == nil {
   105  		b.StopTimer()
   106  		codeInit()
   107  		b.StartTimer()
   108  	}
   109  	b.RunParallel(func(pb *testing.PB) {
   110  		for pb.Next() {
   111  			if _, err := Marshal(&codeStruct); err != nil {
   112  				b.Fatal("Marshal:", err)
   113  			}
   114  		}
   115  	})
   116  	b.SetBytes(int64(len(codeJSON)))
   117  }
   118  
   119  func benchMarshalBytes(n int) func(*testing.B) {
   120  	sample := []byte("hello world")
   121  	// Use a struct pointer, to avoid an allocation when passing it as an
   122  	// interface parameter to Marshal.
   123  	v := &struct {
   124  		Bytes []byte
   125  	}{
   126  		bytes.Repeat(sample, (n/len(sample))+1)[:n],
   127  	}
   128  	return func(b *testing.B) {
   129  		for i := 0; i < b.N; i++ {
   130  			if _, err := Marshal(v); err != nil {
   131  				b.Fatal("Marshal:", err)
   132  			}
   133  		}
   134  	}
   135  }
   136  
   137  func BenchmarkMarshalBytes(b *testing.B) {
   138  	b.ReportAllocs()
   139  	// 32 fits within encodeState.scratch.
   140  	b.Run("32", benchMarshalBytes(32))
   141  	// 256 doesn't fit in encodeState.scratch, but is small enough to
   142  	// allocate and avoid the slower base64.NewEncoder.
   143  	b.Run("256", benchMarshalBytes(256))
   144  	// 4096 is large enough that we want to avoid allocating for it.
   145  	b.Run("4096", benchMarshalBytes(4096))
   146  }
   147  
   148  func BenchmarkCodeDecoder(b *testing.B) {
   149  	b.ReportAllocs()
   150  	if codeJSON == nil {
   151  		b.StopTimer()
   152  		codeInit()
   153  		b.StartTimer()
   154  	}
   155  	b.RunParallel(func(pb *testing.PB) {
   156  		var buf bytes.Buffer
   157  		dec := NewDecoder(&buf)
   158  		var r codeResponse
   159  		for pb.Next() {
   160  			buf.Write(codeJSON)
   161  			// hide EOF
   162  			buf.WriteByte('\n')
   163  			buf.WriteByte('\n')
   164  			buf.WriteByte('\n')
   165  			if err := dec.Decode(&r); err != nil {
   166  				b.Fatal("Decode:", err)
   167  			}
   168  		}
   169  	})
   170  	b.SetBytes(int64(len(codeJSON)))
   171  }
   172  
   173  func BenchmarkUnicodeDecoder(b *testing.B) {
   174  	b.ReportAllocs()
   175  	j := []byte(`"\uD83D\uDE01"`)
   176  	b.SetBytes(int64(len(j)))
   177  	r := bytes.NewReader(j)
   178  	dec := NewDecoder(r)
   179  	var out string
   180  	b.ResetTimer()
   181  	for i := 0; i < b.N; i++ {
   182  		if err := dec.Decode(&out); err != nil {
   183  			b.Fatal("Decode:", err)
   184  		}
   185  		r.Seek(0, 0)
   186  	}
   187  }
   188  
   189  func BenchmarkDecoderStream(b *testing.B) {
   190  	b.ReportAllocs()
   191  	b.StopTimer()
   192  	var buf bytes.Buffer
   193  	dec := NewDecoder(&buf)
   194  	buf.WriteString(`"` + strings.Repeat("x", 1000000) + `"` + "\n\n\n")
   195  	var x interface{}
   196  	if err := dec.Decode(&x); err != nil {
   197  		b.Fatal("Decode:", err)
   198  	}
   199  	ones := strings.Repeat(" 1\n", 300000) + "\n\n\n"
   200  	b.StartTimer()
   201  	for i := 0; i < b.N; i++ {
   202  		if i%300000 == 0 {
   203  			buf.WriteString(ones)
   204  		}
   205  		x = nil
   206  		if err := dec.Decode(&x); err != nil || x != 1.0 {
   207  			b.Fatalf("Decode: %v after %d", err, i)
   208  		}
   209  	}
   210  }
   211  
   212  func BenchmarkCodeUnmarshal(b *testing.B) {
   213  	b.ReportAllocs()
   214  	if codeJSON == nil {
   215  		b.StopTimer()
   216  		codeInit()
   217  		b.StartTimer()
   218  	}
   219  	b.RunParallel(func(pb *testing.PB) {
   220  		for pb.Next() {
   221  			var r codeResponse
   222  			if err := Unmarshal(codeJSON, &r); err != nil {
   223  				b.Fatal("Unmarshal:", err)
   224  			}
   225  		}
   226  	})
   227  	b.SetBytes(int64(len(codeJSON)))
   228  }
   229  
   230  func BenchmarkCodeUnmarshalReuse(b *testing.B) {
   231  	b.ReportAllocs()
   232  	if codeJSON == nil {
   233  		b.StopTimer()
   234  		codeInit()
   235  		b.StartTimer()
   236  	}
   237  	b.RunParallel(func(pb *testing.PB) {
   238  		var r codeResponse
   239  		for pb.Next() {
   240  			if err := Unmarshal(codeJSON, &r); err != nil {
   241  				b.Fatal("Unmarshal:", err)
   242  			}
   243  		}
   244  	})
   245  	b.SetBytes(int64(len(codeJSON)))
   246  }
   247  
   248  func BenchmarkUnmarshalString(b *testing.B) {
   249  	b.ReportAllocs()
   250  	data := []byte(`"hello, world"`)
   251  	b.RunParallel(func(pb *testing.PB) {
   252  		var s string
   253  		for pb.Next() {
   254  			if err := Unmarshal(data, &s); err != nil {
   255  				b.Fatal("Unmarshal:", err)
   256  			}
   257  		}
   258  	})
   259  }
   260  
   261  func BenchmarkUnmarshalFloat64(b *testing.B) {
   262  	b.ReportAllocs()
   263  	data := []byte(`3.14`)
   264  	b.RunParallel(func(pb *testing.PB) {
   265  		var f float64
   266  		for pb.Next() {
   267  			if err := Unmarshal(data, &f); err != nil {
   268  				b.Fatal("Unmarshal:", err)
   269  			}
   270  		}
   271  	})
   272  }
   273  
   274  func BenchmarkUnmarshalInt64(b *testing.B) {
   275  	b.ReportAllocs()
   276  	data := []byte(`3`)
   277  	b.RunParallel(func(pb *testing.PB) {
   278  		var x int64
   279  		for pb.Next() {
   280  			if err := Unmarshal(data, &x); err != nil {
   281  				b.Fatal("Unmarshal:", err)
   282  			}
   283  		}
   284  	})
   285  }
   286  
   287  func BenchmarkIssue10335(b *testing.B) {
   288  	b.ReportAllocs()
   289  	j := []byte(`{"a":{ }}`)
   290  	b.RunParallel(func(pb *testing.PB) {
   291  		var s struct{}
   292  		for pb.Next() {
   293  			if err := Unmarshal(j, &s); err != nil {
   294  				b.Fatal(err)
   295  			}
   296  		}
   297  	})
   298  }
   299  
   300  func BenchmarkIssue34127(b *testing.B) {
   301  	b.ReportAllocs()
   302  	j := struct {
   303  		Bar string `json:"bar,string"`
   304  	}{
   305  		Bar: `foobar`,
   306  	}
   307  	b.RunParallel(func(pb *testing.PB) {
   308  		for pb.Next() {
   309  			if _, err := Marshal(&j); err != nil {
   310  				b.Fatal(err)
   311  			}
   312  		}
   313  	})
   314  }
   315  
   316  func BenchmarkUnmapped(b *testing.B) {
   317  	b.ReportAllocs()
   318  	j := []byte(`{"s": "hello", "y": 2, "o": {"x": 0}, "a": [1, 99, {"x": 1}]}`)
   319  	b.RunParallel(func(pb *testing.PB) {
   320  		var s struct{}
   321  		for pb.Next() {
   322  			if err := Unmarshal(j, &s); err != nil {
   323  				b.Fatal(err)
   324  			}
   325  		}
   326  	})
   327  }
   328  
   329  func BenchmarkTypeFieldsCache(b *testing.B) {
   330  	b.ReportAllocs()
   331  	var maxTypes int = 1e6
   332  	if testenv.Builder() != "" {
   333  		maxTypes = 1e3 // restrict cache sizes on builders
   334  	}
   335  
   336  	// Dynamically generate many new types.
   337  	types := make([]reflect.Type, maxTypes)
   338  	fs := []reflect.StructField{{
   339  		Type:  reflect.TypeOf(""),
   340  		Index: []int{0},
   341  	}}
   342  	for i := range types {
   343  		fs[0].Name = fmt.Sprintf("TypeFieldsCache%d", i)
   344  		types[i] = reflect.StructOf(fs)
   345  	}
   346  
   347  	// clearClear clears the cache. Other JSON operations, must not be running.
   348  	clearCache := func() {
   349  		fieldCache = sync.Map{}
   350  	}
   351  
   352  	// MissTypes tests the performance of repeated cache misses.
   353  	// This measures the time to rebuild a cache of size nt.
   354  	for nt := 1; nt <= maxTypes; nt *= 10 {
   355  		ts := types[:nt]
   356  		b.Run(fmt.Sprintf("MissTypes%d", nt), func(b *testing.B) {
   357  			nc := runtime.GOMAXPROCS(0)
   358  			for i := 0; i < b.N; i++ {
   359  				clearCache()
   360  				var wg sync.WaitGroup
   361  				for j := 0; j < nc; j++ {
   362  					wg.Add(1)
   363  					go func(j int) {
   364  						for _, t := range ts[(j*len(ts))/nc : ((j+1)*len(ts))/nc] {
   365  							cachedTypeFields(t)
   366  						}
   367  						wg.Done()
   368  					}(j)
   369  				}
   370  				wg.Wait()
   371  			}
   372  		})
   373  	}
   374  
   375  	// HitTypes tests the performance of repeated cache hits.
   376  	// This measures the average time of each cache lookup.
   377  	for nt := 1; nt <= maxTypes; nt *= 10 {
   378  		// Pre-warm a cache of size nt.
   379  		clearCache()
   380  		for _, t := range types[:nt] {
   381  			cachedTypeFields(t)
   382  		}
   383  		b.Run(fmt.Sprintf("HitTypes%d", nt), func(b *testing.B) {
   384  			b.RunParallel(func(pb *testing.PB) {
   385  				for pb.Next() {
   386  					cachedTypeFields(types[0])
   387  				}
   388  			})
   389  		})
   390  	}
   391  }
   392  
   393  func BenchmarkEncodeMarshaler(b *testing.B) {
   394  	b.ReportAllocs()
   395  
   396  	m := struct {
   397  		A int
   398  		B RawMessage
   399  	}{}
   400  
   401  	b.RunParallel(func(pb *testing.PB) {
   402  		enc := NewEncoder(io.Discard)
   403  
   404  		for pb.Next() {
   405  			if err := enc.Encode(&m); err != nil {
   406  				b.Fatal("Encode:", err)
   407  			}
   408  		}
   409  	})
   410  }
   411
View as plain text