Subversion Repositories openrisc

// Copyright 2009 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 runtime

// Breakpoint() executes a breakpoint trap.

func Breakpoint()

// LockOSThread wires the calling goroutine to its current operating system thread.

// Until the calling goroutine exits or calls UnlockOSThread, it will always

// execute in that thread, and no other goroutine can.

func LockOSThread()

// UnlockOSThread unwires the calling goroutine from its fixed operating system thread.

// If the calling goroutine has not called LockOSThread, UnlockOSThread is a no-op.

func UnlockOSThread()

// GOMAXPROCS sets the maximum number of CPUs that can be executing

// simultaneously and returns the previous setting.  If n < 1, it does not

// change the current setting.

// The number of logical CPUs on the local machine can be queried with NumCPU.

// This call will go away when the scheduler improves.

func GOMAXPROCS(n int) int

// NumCPU returns the number of logical CPUs on the local machine.

func NumCPU() int

// Cgocalls returns the number of cgo calls made by the current process.

func Cgocalls() int64

// Goroutines returns the number of goroutines that currently exist.

func Goroutines() int32

// Alloc allocates a block of the given size.

// FOR TESTING AND DEBUGGING ONLY.

func Alloc(uintptr) *byte

// Free frees the block starting at the given pointer.

// FOR TESTING AND DEBUGGING ONLY.

func Free(*byte)

// Lookup returns the base and size of the block containing the given pointer.

// FOR TESTING AND DEBUGGING ONLY.

func Lookup(*byte) (*byte, uintptr)

// MemProfileRate controls the fraction of memory allocations

// that are recorded and reported in the memory profile.

// The profiler aims to sample an average of

// one allocation per MemProfileRate bytes allocated.

//

// To include every allocated block in the profile, set MemProfileRate to 1.

// To turn off profiling entirely, set MemProfileRate to 0.

//

// The tools that process the memory profiles assume that the

// profile rate is constant across the lifetime of the program

// and equal to the current value.  Programs that change the

// memory profiling rate should do so just once, as early as

// possible in the execution of the program (for example,

// at the beginning of main).

var MemProfileRate int = 512 * 1024

// A MemProfileRecord describes the live objects allocated

// by a particular call sequence (stack trace).

type MemProfileRecord struct {

        AllocBytes, FreeBytes     int64       // number of bytes allocated, freed

        AllocObjects, FreeObjects int64       // number of objects allocated, freed

        Stack0                    [32]uintptr // stack trace for this record; ends at first 0 entry

}

// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).

func (r *MemProfileRecord) InUseBytes() int64 { return r.AllocBytes - r.FreeBytes }

// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).

func (r *MemProfileRecord) InUseObjects() int64 {

        return r.AllocObjects - r.FreeObjects

}

// Stack returns the stack trace associated with the record,

// a prefix of r.Stack0.

func (r *MemProfileRecord) Stack() []uintptr {

        for i, v := range r.Stack0 {

                if v == 0 {

                        return r.Stack0[0:i]

                }

        }

        return r.Stack0[0:]

}

// MemProfile returns n, the number of records in the current memory profile.

// If len(p) >= n, MemProfile copies the profile into p and returns n, true.

// If len(p) < n, MemProfile does not change p and returns n, false.

//

// If inuseZero is true, the profile includes allocation records

// where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.

// These are sites where memory was allocated, but it has all

// been released back to the runtime.

// Most clients should use the runtime/pprof package or

// the testing package's -test.memprofile flag instead

// of calling MemProfile directly.

func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)

// CPUProfile returns the next chunk of binary CPU profiling stack trace data,

// blocking until data is available.  If profiling is turned off and all the profile

// data accumulated while it was on has been returned, CPUProfile returns nil.

// The caller must save the returned data before calling CPUProfile again.

// Most clients should use the runtime/pprof package or

// the testing package's -test.cpuprofile flag instead of calling

// CPUProfile directly.

func CPUProfile() []byte

// SetCPUProfileRate sets the CPU profiling rate to hz samples per second.

// If hz <= 0, SetCPUProfileRate turns off profiling.

// If the profiler is on, the rate cannot be changed without first turning it off.

// Most clients should use the runtime/pprof package or

// the testing package's -test.cpuprofile flag instead of calling

// SetCPUProfileRate directly.

func SetCPUProfileRate(hz int)