Subversion Repositories openrisc

// 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.

package gob

import (

        "bytes"

        "fmt"

        "io"

        "os"

        "runtime"

        "testing"

)

type Bench struct {

        A int

        B float64

        C string

        D []byte

}

func benchmarkEndToEnd(r io.Reader, w io.Writer, b *testing.B) {

        b.StopTimer()

        enc := NewEncoder(w)

        dec := NewDecoder(r)

        bench := &Bench{7, 3.2, "now is the time", []byte("for all good men")}

        b.StartTimer()

        for i := 0; i < b.N; i++ {

                if enc.Encode(bench) != nil {

                        panic("encode error")

                }

                if dec.Decode(bench) != nil {

                        panic("decode error")

                }

        }

}

func BenchmarkEndToEndPipe(b *testing.B) {

        r, w, err := os.Pipe()

        if err != nil {

                b.Fatal("can't get pipe:", err)

        }

        benchmarkEndToEnd(r, w, b)

}

func BenchmarkEndToEndByteBuffer(b *testing.B) {

        var buf bytes.Buffer

        benchmarkEndToEnd(&buf, &buf, b)

}

func TestCountEncodeMallocs(t *testing.T) {

        var buf bytes.Buffer

        enc := NewEncoder(&buf)

        bench := &Bench{7, 3.2, "now is the time", []byte("for all good men")}

        memstats := new(runtime.MemStats)

        runtime.ReadMemStats(memstats)

        mallocs := 0 - memstats.Mallocs

        const count = 1000

        for i := 0; i < count; i++ {

                err := enc.Encode(bench)

                if err != nil {

                        t.Fatal("encode:", err)

                }

        }

        runtime.ReadMemStats(memstats)

        mallocs += memstats.Mallocs

        fmt.Printf("mallocs per encode of type Bench: %d\n", mallocs/count)

}

func TestCountDecodeMallocs(t *testing.T) {

        var buf bytes.Buffer

        enc := NewEncoder(&buf)

        bench := &Bench{7, 3.2, "now is the time", []byte("for all good men")}

        const count = 1000

        for i := 0; i < count; i++ {

                err := enc.Encode(bench)

                if err != nil {

                        t.Fatal("encode:", err)

                }

        }

        dec := NewDecoder(&buf)

        memstats := new(runtime.MemStats)

        runtime.ReadMemStats(memstats)

        mallocs := 0 - memstats.Mallocs

        for i := 0; i < count; i++ {

                *bench = Bench{}

                err := dec.Decode(&bench)

                if err != nil {

                        t.Fatal("decode:", err)

                }

        }

        runtime.ReadMemStats(memstats)

        mallocs += memstats.Mallocs

        fmt.Printf("mallocs per decode of type Bench: %d\n", mallocs/count)

}