Subversion Repositories openrisc

// Copyright 2012 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 main

import (

        "flag"

        "fmt"

        "log"

        "os"

        "runtime"

        "runtime/pprof"

        "unsafe"

)

const BranchingFactor = 4

type Object struct {

        child [BranchingFactor]*Object

}

var (

        cpus       = flag.Int("cpus", 1, "number of cpus to use")

        heapsize   = flag.Int64("heapsize", 100*1024*1024, "size of the heap in bytes")

        cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")

        lastPauseNs uint64 = 0

        lastFree    uint64 = 0

        heap        *Object

        calls       [20]int

        numobjects  int64

)

func buildHeap() {

        objsize := int64(unsafe.Sizeof(Object{}))

        heap, _ = buildTree(float64(objsize), float64(*heapsize), 0)

        fmt.Printf("*** built heap: %.0f MB; (%d objects * %d bytes)\n",

                float64(*heapsize)/1048576, numobjects, objsize)

}

func buildTree(objsize, size float64, depth int) (*Object, float64) {

        calls[depth]++

        x := &Object{}

        numobjects++

        subtreeSize := (size - objsize) / BranchingFactor

        alloc := objsize

        for i := 0; i < BranchingFactor && alloc < size; i++ {

                c, n := buildTree(objsize, subtreeSize, depth+1)

                x.child[i] = c

                alloc += n

        }

        return x, alloc

}

func gc() {

        runtime.GC()

        runtime.UpdateMemStats()

        pause := runtime.MemStats.PauseTotalNs

        inuse := runtime.MemStats.Alloc

        free := runtime.MemStats.TotalAlloc - inuse

        fmt.Printf("gc pause: %8.3f ms; collect: %8.0f MB; heapsize: %8.0f MB\n",

                float64(pause-lastPauseNs)/1e6,

                float64(free-lastFree)/1048576,

                float64(inuse)/1048576)

        lastPauseNs = pause

        lastFree = free

}

func main() {

        flag.Parse()

        buildHeap()

        runtime.GOMAXPROCS(*cpus)

        runtime.UpdateMemStats()

        lastPauseNs = runtime.MemStats.PauseTotalNs

        lastFree = runtime.MemStats.TotalAlloc - runtime.MemStats.Alloc

        if *cpuprofile != "" {

                f, err := os.Create(*cpuprofile)

                if err != nil {

                        log.Fatal(err)

                }

                pprof.StartCPUProfile(f)

                defer pprof.StopCPUProfile()

        }

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

                gc()

        }

}