malloc bug fixes.

use malloc by default.
free stacks.

R=r
DELTA=424  (333 added, 29 deleted, 62 changed)
OCL=21553
CL=21584

2 files changed, 133 insertions, 1 deletions

diff --git a/test/mallocrep.go b/test/mallocrep.go
index 2911b4a05..8373cc0eb 100644
--- a/test/mallocrep.go
+++ b/test/mallocrep.go
@@ -31,15 +31,17 @@ func bigger() {
 
 func main() {
 	flag.Parse();
+	malloc.GetStats().alloc = 0;	// ignore stacks
 	for i := 0; i < 1<<8; i++ {
 		for j := 1; j <= 1<<22; j<<=1 {
 			if i == 0 && chatty {
 				println("First alloc:", j);
 			}
 			b := malloc.Alloc(uint64(j));
+			during := malloc.GetStats().alloc;
 			malloc.Free(b);
 			if a := malloc.GetStats().alloc; a != 0 {
-				panicln("malloc wrong count", a);
+				panicln("malloc wrong count", a, "after", j, "during", during);
 			}
 			bigger();
 		}
diff --git a/test/mallocrep1.go b/test/mallocrep1.go
new file mode 100644
index 000000000..50f557b7a
--- /dev/null
+++ b/test/mallocrep1.go
@@ -0,0 +1,130 @@
+// $G $D/$F.go && $L $F.$A && ./$A.out
+
+// 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.
+
+package main
+
+import (
+	"flag";
+	"fmt";
+	"malloc";
+	"strconv"
+)
+
+var chatty bool;
+var chatty_flag = flag.Bool("v", false, &chatty, "chatty");
+var reverse bool;
+var reverse_flag = flag.Bool("r", false, &reverse, "reverse");
+var longtest bool;
+var longtest_flag = flag.Bool("l", false, &longtest, "long test");
+
+var b *[]*byte;
+var stats = malloc.GetStats();
+
+func OkAmount(size, n uint64) 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) {
+	if chatty {
+		fmt.printf("size=%d count=%d ...\n", size, count);
+	}
+	n1 := stats.alloc;
+	for i := 0; i < count; i++ {
+		b[i] = malloc.Alloc(uint64(size));
+		base, n := malloc.Lookup(b[i]);
+		if base != b[i] || !OkAmount(uint64(size), n) {
+			panicln("lookup failed: got", base, n, "for", b[i]);
+		}
+		if malloc.GetStats().sys > 1e9 {
+			panicln("too much memory allocated");
+		}
+	}
+	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 := stats.alloc;
+		base, n := malloc.Lookup(b[i]);
+		if base != b[i] || !OkAmount(uint64(size), n) {
+			panicln("lookup failed: got", base, n, "for", b[i]);
+		}
+		malloc.Free(b[i]);
+		if stats.alloc != alloc - n {
+			panicln("free alloc got", stats.alloc, "expected", alloc - n, "after free of", n);
+		}
+		if malloc.GetStats().sys > 1e9 {
+			panicln("too much memory allocated");
+		}
+	}
+	n4 := stats.alloc;
+
+	if chatty {
+		fmt.printf("size=%d count=%d stats=%+v\n", size, count, *stats);
+	}
+	if n2-n1 != n3-n4 {
+		panicln("wrong alloc count: ", n2-n1, n3-n4);
+	}
+}
+
+func atoi(s string) int {
+	i, xx1 := strconv.atoi(s);
+	return i
+}
+
+func main() {
+	flag.Parse();
+	b = new([]*byte, 10000);
+	if flag.NArg() > 0 {
+		AllocAndFree(atoi(flag.Arg(0)), atoi(flag.Arg(1)));
+		return;
+	}
+	for j := 1; j <= 1<<22; j<<=1 {
+		n := len(b);
+		max := uint64(1<<28);
+		if !longtest {
+			max = 1<<22;
+		}
+		if uint64(j)*uint64(n) > max {
+			n = int(max / uint64(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
+			}
+		}
+	}
+}