Subversion Repositories openrisc

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

// Garbage collection benchmark: parse Go packages repeatedly.

package main

import (
        "flag"
        "fmt"
        "go/ast"
        "go/parser"
        "go/token"
        "log"
        "net/http"
        _ "net/http/pprof"
        "os"
        "path"
        "runtime"
        "strings"
        "time"
)

var serve = flag.String("serve", "", "serve http on this address at end")

func isGoFile(dir os.FileInfo) bool {
        return !dir.IsDir() &&
                !strings.HasPrefix(dir.Name(), ".") && // ignore .files
                path.Ext(dir.Name()) == ".go"
}

func isPkgFile(dir os.FileInfo) bool {
        return isGoFile(dir) &&
                !strings.HasSuffix(dir.Name(), "_test.go") // ignore test files
}

func pkgName(filename string) string {
        file, err := parser.ParseFile(token.NewFileSet(), filename, nil, parser.PackageClauseOnly)
        if err != nil || file == nil {
                return ""
        }
        return file.Name.Name
}

func parseDir(dirpath string) map[string]*ast.Package {
        // the package name is the directory name within its parent
        // (use dirname instead of path because dirname is clean; i.e. has no trailing '/')
        _, pkgname := path.Split(dirpath)

        // filter function to select the desired .go files
        filter := func(d os.FileInfo) bool {
                if isPkgFile(d) {
                        // Some directories contain main packages: Only accept
                        // files that belong to the expected package so that
                        // parser.ParsePackage doesn't return "multiple packages
                        // found" errors.
                        // Additionally, accept the special package name
                        // fakePkgName if we are looking at cmd documentation.
                        name := pkgName(dirpath + "/" + d.Name())
                        return name == pkgname
                }
                return false
        }

        // get package AST
        pkgs, err := parser.ParseDir(token.NewFileSet(), dirpath, filter, parser.ParseComments)
        if err != nil {
                println("parse", dirpath, err.Error())
                panic("fail")
        }
        return pkgs
}

func main() {
        st := &runtime.MemStats
        packages = append(packages, packages...)
        packages = append(packages, packages...)
        n := flag.Int("n", 4, "iterations")
        p := flag.Int("p", len(packages), "# of packages to keep in memory")
        flag.BoolVar(&st.DebugGC, "d", st.DebugGC, "print GC debugging info (pause times)")
        flag.Parse()

        var lastParsed []map[string]*ast.Package
        var t0 time.Time
        pkgroot := runtime.GOROOT() + "/src/pkg/"
        for pass := 0; pass < 2; pass++ {
                // Once the heap is grown to full size, reset counters.
                // This hides the start-up pauses, which are much smaller
                // than the normal pauses and would otherwise make
                // the average look much better than it actually is.
                st.NumGC = 0
                st.PauseTotalNs = 0
                t0 = time.Now()

                for i := 0; i < *n; i++ {
                        parsed := make([]map[string]*ast.Package, *p)
                        for j := range parsed {
                                parsed[j] = parseDir(pkgroot + packages[j%len(packages)])
                        }
                        if i+1 == *n && *serve != "" {
                                lastParsed = parsed
                        }
                }
                runtime.GC()
                runtime.GC()
        }
        t1 := time.Now()

        fmt.Printf("Alloc=%d/%d Heap=%d Mallocs=%d PauseTime=%.3f/%d = %.3f\n",
                st.Alloc, st.TotalAlloc,
                st.Sys,
                st.Mallocs, float64(st.PauseTotalNs)/1e9,
                st.NumGC, float64(st.PauseTotalNs)/1e9/float64(st.NumGC))

        /*
                fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free")
                for _, s := range st.BySize {
                        fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees)
                }
        */
        // Standard gotest benchmark output, collected by build dashboard.
        gcstats("BenchmarkParser", *n, t1.Sub(t0))

        if *serve != "" {
                log.Fatal(http.ListenAndServe(*serve, nil))
                println(lastParsed)
        }
}

var packages = []string{
        "archive/tar",
        "encoding/asn1",
        "math/big",
        "bufio",
        "bytes",
        "math/cmplx",
        "compress/flate",
        "compress/gzip",
        "compress/zlib",
        "container/heap",
        "container/list",
        "container/ring",
        "crypto/aes",
        "crypto/blowfish",
        "crypto/hmac",
        "crypto/md4",
        "crypto/md5",
        "crypto/rand",
        "crypto/rc4",
        "crypto/rsa",
        "crypto/sha1",
        "crypto/sha256",
        "crypto/sha512",
        "crypto/subtle",
        "crypto/tls",
        "crypto/x509",
        "crypto/xtea",
        "debug/dwarf",
        "debug/macho",
        "debug/elf",
        "debug/gosym",
        "exp/ebnf",
        "encoding/ascii85",
        "encoding/base64",
        "encoding/binary",
        "encoding/git85",
        "encoding/hex",
        "encoding/pem",
        "os/exec",
        "flag",
        "fmt",
        "go/ast",
        "go/doc",
        "go/parser",
        "go/printer",
        "go/scanner",
        "go/token",
        "encoding/gob",
        "hash",
        "hash/adler32",
        "hash/crc32",
        "hash/crc64",
        "net/http",
        "image",
        "image/jpeg",
        "image/png",
        "io",
        "io/ioutil",
        "encoding/json",
        "log",
        "math",
        "mime",
        "net",
        "os",
        "os/signal",
        "patch",
        "path",
        "math/rand",
        "reflect",
        "regexp",
        "net/rpc",
        "runtime",
        "text/scanner",
        "sort",
        "net/smtp",
        "strconv",
        "strings",
        "sync",
        "syscall",
        "log/syslog",
        "text/tabwriter",
        "text/template",
        "testing",
        "testing/iotest",
        "testing/quick",
        "testing/script",
        "time",
        "unicode",
        "unicode/utf8",
        "unicode/utf16",
        "websocket",
        "encoding/xml",
}