qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 20:54:39 -07:00
Code Releases Activity

runtime: remove old malloc test programs

Browse Source 
These haven't been run in ages.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews, iant, khr, r
https://golang.org/cl/134170043
This commit is contained in:
Russ Cox 2014-09-01 00:40:28 -04:00
parent 76fb8a5e41
commit 933169febb
4 changed files with 0 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/pkg/runtime/malloc1.go
View File

@ -1,26 +0,0 @@
// 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.
// +build ignore
// trivial malloc test
package main
import (
"flag"
"fmt"
"runtime"
)
var chatty = flag.Bool("v", false, "chatty")
func main() {
memstats := new(runtime.MemStats)
runtime.Free(runtime.Alloc(1))
runtime.ReadMemStats(memstats)
if *chatty {
fmt.Printf("%+v %v\n", memstats, uint64(0))
}
}

93
src/pkg/runtime/mallocrand.go
View File

@ -1,93 +0,0 @@
// 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.
// +build ignore
// Random malloc test.
package main
import (
"flag"
"math/rand"
"runtime"
"unsafe"
)
var chatty = flag.Bool("v", false, "chatty")
var footprint uint64
var allocated uint64
func bigger() {
memstats := new(runtime.MemStats)
runtime.ReadMemStats(memstats)
if f := memstats.Sys; footprint < f {
footprint = f
if *chatty {
println("Footprint", footprint, " for ", allocated)
}
if footprint > 1e9 {
println("too big")
panic("fail")
}
}
}
// Prime the data structures by allocating one of
// each block in order. After this, there should be
// little reason to ask for more memory from the OS.
func prime() {
for i := 0; i < 16; i++ {
b := runtime.Alloc(1 << uint(i))
runtime.Free(b)
}
for i := uintptr(0); i < 256; i++ {
b := runtime.Alloc(i << 12)
runtime.Free(b)
}
}
func memset(b *byte, c byte, n uintptr) {
np := uintptr(n)
for i := uintptr(0); i < np; i++ {
*(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b)) + i)) = c
}
}
func main() {
flag.Parse()
// prime()
var blocks [1]struct {
base *byte
siz uintptr
}
for i := 0; i < 1<<10; i++ {
if i%(1<<10) == 0 && *chatty {
println(i)
}
b := rand.Int() % len(blocks)
if blocks[b].base != nil {
// println("Free", blocks[b].siz, blocks[b].base)
runtime.Free(blocks[b].base)
blocks[b].base = nil
allocated -= uint64(blocks[b].siz)
continue
}
siz := uintptr(rand.Int() >> (11 + rand.Uint32()%20))
base := runtime.Alloc(siz)
// ptr := uintptr(syscall.BytePtr(base))+uintptr(siz/2)
// obj, size, ref, ok := allocator.find(ptr)
// if obj != base || *ref != 0 || !ok {
// println("find", siz, obj, ref, ok)
// panic("fail")
// }
blocks[b].base = base
blocks[b].siz = siz
allocated += uint64(siz)
// println("Alloc", siz, base)
memset(base, 0xbb, siz)
bigger()
}
}

72
src/pkg/runtime/mallocrep.go
View File

@ -1,72 +0,0 @@
// 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.
// Repeated malloc test.
// +build ignore
package main
import (
"flag"
"runtime"
)
var chatty = flag.Bool("v", false, "chatty")
var oldsys uint64
var memstats runtime.MemStats
func bigger() {
st := &memstats
runtime.ReadMemStats(st)
if oldsys < st.Sys {
oldsys = st.Sys
if *chatty {
println(st.Sys, " system bytes for ", st.Alloc, " Go bytes")
}
if st.Sys > 1e9 {
println("too big")
panic("fail")
}
}
}
func main() {
runtime.GC() // clean up garbage from init
runtime.ReadMemStats(&memstats) // first call can do some allocations
runtime.MemProfileRate = 0 // disable profiler
stacks := memstats.Alloc // ignore stacks
flag.Parse()
for i := 0; i < 1<<7; i++ {
for j := 1; j <= 1<<22; j <<= 1 {
if i == 0 && *chatty {
println("First alloc:", j)
}
if a := memstats.Alloc - stacks; a != 0 {
println("no allocations but stats report", a, "bytes allocated")
panic("fail")
}
b := runtime.Alloc(uintptr(j))
runtime.ReadMemStats(&memstats)
during := memstats.Alloc - stacks
runtime.Free(b)
runtime.ReadMemStats(&memstats)
if a := memstats.Alloc - stacks; a != 0 {
println("allocated ", j, ": wrong stats: during=", during, " after=", a, " (want 0)")
panic("fail")
}
bigger()
}
if i%(1<<10) == 0 && *chatty {
println(i)
}
if i == 0 {
if *chatty {
println("Primed", i)
}
// runtime.frozen = true
}
}
}

144
src/pkg/runtime/mallocrep1.go
View File

@ -1,144 +0,0 @@
// 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.
// +build ignore
// Repeated malloc test.
package main
import (
"flag"
"fmt"
"runtime"
"strconv"
)
var chatty = flag.Bool("v", false, "chatty")
var reverse = flag.Bool("r", false, "reverse")
var longtest = flag.Bool("l", false, "long test")
var b []*byte
var stats = new(runtime.MemStats)
func OkAmount(size, n uintptr) bool {
if n < size {
return false
}
if size < 16*8 {
if n > size+16 {
return false
}
} else {
if n > size*9/8 {
return false
}
}
return true
}
func AllocAndFree(size, count int) {
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
if *chatty {
fmt.Printf("size=%d count=%d ...\n", size, count)
}
runtime.ReadMemStats(stats)
n1 := stats.Alloc
for i := 0; i < count; i++ {
b[i] = runtime.Alloc(uintptr(size))
base, n := runtime.Lookup(b[i])
if base != b[i] || !OkAmount(uintptr(size), n) {
println("lookup failed: got", base, n, "for", b[i])
panic("fail")
}
runtime.ReadMemStats(stats)
if stats.Sys > 1e9 {
println("too much memory allocated")
panic("fail")
}
}
runtime.ReadMemStats(stats)
n2 := stats.Alloc
if *chatty {
fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
}
n3 := stats.Alloc
for j := 0; j < count; j++ {
i := j
if *reverse {
i = count - 1 - j
}
alloc := uintptr(stats.Alloc)
base, n := runtime.Lookup(b[i])
if base != b[i] || !OkAmount(uintptr(size), n) {
println("lookup failed: got", base, n, "for", b[i])
panic("fail")
}
runtime.Free(b[i])
runtime.ReadMemStats(stats)
if stats.Alloc != uint64(alloc-n) {
println("free alloc got", stats.Alloc, "expected", alloc-n, "after free of", n)
panic("fail")
}
if stats.Sys > 1e9 {
println("too much memory allocated")
panic("fail")
}
}
runtime.ReadMemStats(stats)
n4 := stats.Alloc
if *chatty {
fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
}
if n2-n1 != n3-n4 {
println("wrong alloc count: ", n2-n1, n3-n4)
panic("fail")
}
}
func atoi(s string) int {
i, _ := strconv.Atoi(s)
return i
}
func main() {
runtime.MemProfileRate = 0 // disable profiler
flag.Parse()
b = make([]*byte, 10000)
if flag.NArg() > 0 {
AllocAndFree(atoi(flag.Arg(0)), atoi(flag.Arg(1)))
return
}
maxb := 1 << 22
if !*longtest {
maxb = 1 << 19
}
for j := 1; j <= maxb; j <<= 1 {
n := len(b)
max := uintptr(1 << 28)
if !*longtest {
max = uintptr(maxb)
}
if uintptr(j)*uintptr(n) > max {
n = int(max / uintptr(j))
}
if n < 10 {
n = 10
}
for m := 1; m <= n; {
AllocAndFree(j, m)
if m == n {
break
}
m = 5 * m / 4
if m < 4 {
m++
}
if m > n {
m = n
}
}
}
}