gcc/testsuite/go.test/test/mallocrep1.go

   1 // $G $D/$F.go && $L $F.$A && ./$A.out
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Repeated malloc test.
   8
   9 package main
  10
  11 import (
  12         "flag"
  13         "fmt"
  14         "runtime"
  15         "strconv"
  16 )
  17
  18 var chatty = flag.Bool("v", false, "chatty")
  19 var reverse = flag.Bool("r", false, "reverse")
  20 var longtest = flag.Bool("l", false, "long test")
  21
  22 var b []*byte
  23 var stats = &runtime.MemStats
  24
  25 func OkAmount(size, n uintptr) bool {
  26         if n < size {
  27                 return false
  28         }
  29         if size < 16*8 {
  30                 if n > size+16 {
  31                         return false
  32                 }
  33         } else {
  34                 if n > size*9/8 {
  35                         return false
  36                 }
  37         }
  38         return true
  39 }
  40
  41 func AllocAndFree(size, count int) {
  42         if *chatty {
  43                 fmt.Printf("size=%d count=%d ...\n", size, count)
  44         }
  45         n1 := stats.Alloc
  46         for i := 0; i < count; i++ {
  47                 b[i] = runtime.Alloc(uintptr(size))
  48                 base, n := runtime.Lookup(b[i])
  49                 if base != b[i] || !OkAmount(uintptr(size), n) {
  50                         println("lookup failed: got", base, n, "for", b[i])
  51                         panic("fail")
  52                 }
  53                 if runtime.MemStats.Sys > 1e9 {
  54                         println("too much memory allocated")
  55                         panic("fail")
  56                 }
  57         }
  58         n2 := stats.Alloc
  59         if *chatty {
  60                 fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
  61         }
  62         n3 := stats.Alloc
  63         for j := 0; j < count; j++ {
  64                 i := j
  65                 if *reverse {
  66                         i = count - 1 - j
  67                 }
  68                 alloc := uintptr(stats.Alloc)
  69                 base, n := runtime.Lookup(b[i])
  70                 if base != b[i] || !OkAmount(uintptr(size), n) {
  71                         println("lookup failed: got", base, n, "for", b[i])
  72                         panic("fail")
  73                 }
  74                 runtime.Free(b[i])
  75                 if stats.Alloc != uint64(alloc-n) {
  76                         println("free alloc got", stats.Alloc, "expected", alloc-n, "after free of", n)
  77                         panic("fail")
  78                 }
  79                 if runtime.MemStats.Sys > 1e9 {
  80                         println("too much memory allocated")
  81                         panic("fail")
  82                 }
  83         }
  84         n4 := stats.Alloc
  85
  86         if *chatty {
  87                 fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
  88         }
  89         if n2-n1 != n3-n4 {
  90                 println("wrong alloc count: ", n2-n1, n3-n4)
  91                 panic("fail")
  92         }
  93 }
  94
  95 func atoi(s string) int {
  96         i, _ := strconv.Atoi(s)
  97         return i
  98 }
  99
 100 func main() {
 101         runtime.MemProfileRate = 0 // disable profiler
 102         flag.Parse()
 103         b = make([]*byte, 10000)
 104         if flag.NArg() > 0 {
 105                 AllocAndFree(atoi(flag.Arg(0)), atoi(flag.Arg(1)))
 106                 return
 107         }
 108         maxb := 1 << 22
 109         if !*longtest {
 110                 maxb = 1 << 19
 111         }
 112         for j := 1; j <= maxb; j <<= 1 {
 113                 n := len(b)
 114                 max := uintptr(1 << 28)
 115                 if !*longtest {
 116                         max = uintptr(maxb)
 117                 }
 118                 if uintptr(j)*uintptr(n) > max {
 119                         n = int(max / uintptr(j))
 120                 }
 121                 if n < 10 {
 122                         n = 10
 123                 }
 124                 for m := 1; m <= n; {
 125                         AllocAndFree(j, m)
 126                         if m == n {
 127                                 break
 128                         }
 129                         m = 5 * m / 4
 130                         if m < 4 {
 131                                 m++
 132                         }
 133                         if m > n {
 134                                 m = n
 135                         }
 136                 }
 137         }
 138 }