OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [encoding/] [json/] [bench_test.go] - Blame information for rev 750

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// 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 
        "io/ioutil"
17 
        "os"
18 
        "testing"
19 
)
20 
 
21 
type codeResponse struct {
22 
        Tree     *codeNode `json:"tree"`
23 
        Username string    `json:"username"`
24 
}
25 
 
26 
type codeNode struct {
27 
        Name     string      `json:"name"`
28 
        Kids     []*codeNode `json:"kids"`
29 
        CLWeight float64     `json:"cl_weight"`
30 
        Touches  int         `json:"touches"`
31 
        MinT     int64       `json:"min_t"`
32 
        MaxT     int64       `json:"max_t"`
33 
        MeanT    int64       `json:"mean_t"`
34 
}
35 
 
36 
var codeJSON []byte
37 
var codeStruct codeResponse
38 
 
39 
func codeInit() {
40 
        f, err := os.Open("testdata/code.json.gz")
41 
        if err != nil {
42 
                panic(err)
43 
        }
44 
        defer f.Close()
45 
        gz, err := gzip.NewReader(f)
46 
        if err != nil {
47 
                panic(err)
48 
        }
49 
        data, err := ioutil.ReadAll(gz)
50 
        if err != nil {
51 
                panic(err)
52 
        }
53 
 
54 
        codeJSON = data
55 
 
56 
        if err := Unmarshal(codeJSON, &codeStruct); err != nil {
57 
                panic("unmarshal code.json: " + err.Error())
58 
        }
59 
 
60 
        if data, err = Marshal(&codeStruct); err != nil {
61 
                panic("marshal code.json: " + err.Error())
62 
        }
63 
 
64 
        if !bytes.Equal(data, codeJSON) {
65 
                println("different lengths", len(data), len(codeJSON))
66 
                for i := 0; i < len(data) && i < len(codeJSON); i++ {
67 
                        if data[i] != codeJSON[i] {
68 
                                println("re-marshal: changed at byte", i)
69 
                                println("orig: ", string(codeJSON[i-10:i+10]))
70 
                                println("new: ", string(data[i-10:i+10]))
71 
                                break
72 
                        }
73 
                }
74 
                panic("re-marshal code.json: different result")
75 
        }
76 
}
77 
 
78 
func BenchmarkCodeEncoder(b *testing.B) {
79 
        if codeJSON == nil {
80 
                b.StopTimer()
81 
                codeInit()
82 
                b.StartTimer()
83 
        }
84 
        enc := NewEncoder(ioutil.Discard)
85 
        for i := 0; i < b.N; i++ {
86 
                if err := enc.Encode(&codeStruct); err != nil {
87 
                        b.Fatal("Encode:", err)
88 
                }
89 
        }
90 
        b.SetBytes(int64(len(codeJSON)))
91 
}
92 
 
93 
func BenchmarkCodeMarshal(b *testing.B) {
94 
        if codeJSON == nil {
95 
                b.StopTimer()
96 
                codeInit()
97 
                b.StartTimer()
98 
        }
99 
        for i := 0; i < b.N; i++ {
100 
                if _, err := Marshal(&codeStruct); err != nil {
101 
                        b.Fatal("Marshal:", err)
102 
                }
103 
        }
104 
        b.SetBytes(int64(len(codeJSON)))
105 
}
106 
 
107 
func BenchmarkCodeDecoder(b *testing.B) {
108 
        if codeJSON == nil {
109 
                b.StopTimer()
110 
                codeInit()
111 
                b.StartTimer()
112 
        }
113 
        var buf bytes.Buffer
114 
        dec := NewDecoder(&buf)
115 
        var r codeResponse
116 
        for i := 0; i < b.N; i++ {
117 
                buf.Write(codeJSON)
118 
                // hide EOF
119 
                buf.WriteByte('\n')
120 
                buf.WriteByte('\n')
121 
                buf.WriteByte('\n')
122 
                if err := dec.Decode(&r); err != nil {
123 
                        b.Fatal("Decode:", err)
124 
                }
125 
        }
126 
        b.SetBytes(int64(len(codeJSON)))
127 
}
128 
 
129 
func BenchmarkCodeUnmarshal(b *testing.B) {
130 
        if codeJSON == nil {
131 
                b.StopTimer()
132 
                codeInit()
133 
                b.StartTimer()
134 
        }
135 
        for i := 0; i < b.N; i++ {
136 
                var r codeResponse
137 
                if err := Unmarshal(codeJSON, &r); err != nil {
138 
                        b.Fatal("Unmmarshal:", err)
139 
                }
140 
        }
141 
        b.SetBytes(int64(len(codeJSON)))
142 
}
143 
 
144 
func BenchmarkCodeUnmarshalReuse(b *testing.B) {
145 
        if codeJSON == nil {
146 
                b.StopTimer()
147 
                codeInit()
148 
                b.StartTimer()
149 
        }
150 
        var r codeResponse
151 
        for i := 0; i < b.N; i++ {
152 
                if err := Unmarshal(codeJSON, &r); err != nil {
153 
                        b.Fatal("Unmmarshal:", err)
154 
                }
155 
        }
156 
        b.SetBytes(int64(len(codeJSON)))
157 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.