Memory Improvement

bfs.go

@@ -7,17 +7,20 @@ package graph
 func BFS(g Iterator, v int, do func(v, w int, c int64)) {
 	visited := make([]bool, g.Order())
 	visited[v] = true
-	for queue := []int{v}; len(queue) > 0; {
-		v := queue[0]
-		queue = queue[1:]
-		g.Visit(v, func(w int, c int64) (skip bool) {
-			if visited[w] {
-				return
-			}
-			do(v, w, c)
-			visited[w] = true
-			queue = append(queue, w)
+	queue := []int{v}
+
+	fn := func(w int, c int64) (skip bool) {
+		if visited[w] {
 			return
-		})
+		}
+		do(v, w, c)
+		visited[w] = true
+		queue = append(queue, w)
+		return
+	}
+	for len(queue) > 0 {
+		v = queue[0]
+		queue = queue[1:]
+		g.Visit(v, fn)
 	}
 }

bfs_test.go

@@ -1,6 +1,7 @@
 package graph
 
 import (
+	"math/rand"
 	"strconv"
 	"testing"
 )
@@ -26,3 +27,19 @@ func TestBFS(t *testing.T) {
 		t.Errorf("BFS: %s", mess)
 	}
 }
+
+func BenchmarkBFS(b *testing.B) {
+	n := 1000
+	g := New(n)
+	for i := 0; i < 5*n; i++ {
+		g.AddBoth(rand.Intn(n), rand.Intn(n))
+	}
+
+	fn := func(v, w int, c int64) {}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		BFS(g, 0, fn)
+	}
+}

bipart.go

@@ -12,31 +12,36 @@ func Bipartition(g Iterator) (part []int, ok bool) {
 	)
 	colors := make([]color, g.Order())
 	whiteCount := 0
+
+	var src int
+	var queue []int
+	do := func(w int, _ int64) (skip bool) {
+		v := src
+		switch {
+		case colors[w] != none:
+			if colors[v] == colors[w] {
+				skip = true
+			}
+			return
+		case colors[v] == white:
+			colors[w] = black
+		default:
+			colors[w] = white
+			whiteCount++
+		}
+		queue = append(queue, w)
+		return
+	}
 	for v := range colors {
 		if colors[v] != none {
 			continue
 		}
 		colors[v] = white
 		whiteCount++
-		for queue := []int{v}; len(queue) > 0; {
-			v := queue[0]
+		for queue = []int{v}; len(queue) > 0; {
+			src = queue[0]
 			queue = queue[1:]
-			if g.Visit(v, func(w int, _ int64) (skip bool) {
-				switch {
-				case colors[w] != none:
-					if colors[v] == colors[w] {
-						skip = true
-					}
-					return
-				case colors[v] == white:
-					colors[w] = black
-				default:
-					colors[w] = white
-					whiteCount++
-				}
-				queue = append(queue, w)
-				return
-			}) {
+			if g.Visit(src, do) {
 				return []int{}, false
 			}
 		}

bipart_test.go

@@ -1,6 +1,7 @@
 package graph
 
 import (
+	"math/rand"
 	"testing"
 )
 
@@ -93,3 +94,18 @@ func TestBipartition(t *testing.T) {
 		t.Errorf("Bipartition: %s", mess)
 	}
 }
+
+func BenchmarkBipartition(b *testing.B) {
+	n := 1000
+	g := New(n)
+	for i := 0; i < 3*n; i++ {
+		g.AddBoth(rand.Intn(n), rand.Intn(n))
+	}
+	h := Sort(g)
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = Bipartition(h)
+	}
+}

euler.go

@@ -6,13 +6,18 @@ func EulerDirected(g Iterator) (walk []int, ok bool) {
 	n := g.Order()
 	degree := make([]int, n) // outdegree - indegree for each vertex
 	edgeCount := 0
+
+	var src int
+	degreeFn := func(w int, _ int64) (skip bool) {
+		v := src
+		edgeCount++
+		degree[v]++
+		degree[w]--
+		return
+	}
 	for v := range degree {
-		g.Visit(v, func(w int, _ int64) (skip bool) {
-			edgeCount++
-			degree[v]++
-			degree[w]--
-			return
-		})
+		src = v
+		g.Visit(src, degreeFn)
 	}
 	if edgeCount == 0 {
 		return []int{}, true
@@ -33,11 +38,14 @@ func EulerDirected(g Iterator) (walk []int, ok bool) {
 
 	// Make a copy of g
 	h := make([][]int, n)
+	copyFn := func(w int, _ int64) (skip bool) {
+		v := src
+		h[v] = append(h[v], w)
+		return
+	}
 	for v := range h {
-		g.Visit(v, func(w int, _ int64) (skip bool) {
-			h[v] = append(h[v], w)
-			return
-		})
+		src = v
+		g.Visit(src, copyFn)
 	}
 
 	// Find a starting point with neighbors.
@@ -77,14 +85,19 @@ func EulerUndirected(g Iterator) (walk []int, ok bool) {
 	n := g.Order()
 	out := make([]int, n) // outdegree for each vertex
 	edgeCount := 0
+
+	var src int
+	outDegreeFn := func(w int, _ int64) (skip bool) {
+		v := src
+		edgeCount++
+		if v != w {
+			out[v]++
+		}
+		return
+	}
 	for v := range out {
-		g.Visit(v, func(w int, _ int64) (skip bool) {
-			edgeCount++
-			if v != w {
-				out[v]++
-			}
-			return
-		})
+		src = v
+		g.Visit(src, outDegreeFn)
 	}
 	if edgeCount == 0 {
 		return []int{}, true

euler_test.go

@@ -1,6 +1,7 @@
 package graph
 
 import (
+	"math/rand"
 	"testing"
 )
 
@@ -155,3 +156,39 @@ func TestEulerUndirected(t *testing.T) {
 		t.Errorf("EulerUndirected: %s", mess)
 	}
 }
+
+func BenchmarkEulerDirected(b *testing.B) {
+	n := 100
+	g := New(n)
+	for i := 0; i < n-1; i++ {
+		g.Add(i, i+1)
+	}
+	for i := 0; i < 3*n; i++ {
+		g.Add(rand.Intn(n), rand.Intn(n))
+	}
+	h := Sort(g)
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = EulerDirected(h)
+	}
+}
+
+func BenchmarkEulerUndirected(b *testing.B) {
+	n := 100
+	g := New(n)
+	for i := 0; i < n-1; i++ {
+		g.AddBoth(i, i+1)
+	}
+	for i := 0; i < 3*n; i++ {
+		g.Add(rand.Intn(n), rand.Intn(n))
+	}
+	h := Sort(g)
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = EulerUndirected(h)
+	}
+}

immutable.go

@@ -41,18 +41,21 @@ func Transpose(g Iterator) *Immutable {
 func build(g Iterator, transpose bool) *Immutable {
 	n := g.Order()
 	h := &Immutable{edges: make([][]neighbor, n)}
-	for v := range h.edges {
-		g.Visit(v, func(w int, c int64) (skip bool) {
-			if w < 0 || w >= n {
-				panic("vertex out of range: " + strconv.Itoa(w))
-			}
-			if transpose {
-				h.edges[w] = append(h.edges[w], neighbor{v, c})
-			} else {
-				h.edges[v] = append(h.edges[v], neighbor{w, c})
-			}
-			return
-		})
+
+	var v int
+	do := func(w int, c int64) (skip bool) {
+		if w < 0 || w >= n {
+			panic("vertex out of range: " + strconv.Itoa(w))
+		}
+		if transpose {
+			h.edges[w] = append(h.edges[w], neighbor{v, c})
+		} else {
+			h.edges[v] = append(h.edges[v], neighbor{w, c})
+		}
+		return
+	}
+	for v = range h.edges {
+		g.Visit(v, do)
 		sort.Slice(h.edges[v], func(i, j int) bool {
 			if e := h.edges[v]; e[i].vertex == e[j].vertex {
 				return e[i].cost < e[j].cost

immutable_test.go

@@ -197,3 +197,29 @@ func TestDegreeImm(t *testing.T) {
 		t.Errorf("g5c.Degree(1) %s", mess)
 	}
 }
+
+func BenchmarkSort(b *testing.B) {
+	n := 1000
+	g := New(n)
+	for i := 0; i < 3*n; i++ {
+		g.Add(rand.Intn(n), rand.Intn(n))
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = Sort(g)
+	}
+}
+
+func BenchmarkTranspose(b *testing.B) {
+	n := 1000
+	g := New(n)
+	for i := 0; i < 3*n; i++ {
+		g.Add(rand.Intn(n), rand.Intn(n))
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = Transpose(g)
+	}
+}

mst.go

@@ -19,16 +19,18 @@ func MST(g Iterator) (parent []int) {
 
 	// Prim's algorithm
 	Q := newPrioQueue(cost)
+	var v int
+	do := func(w int, c int64) (skip bool) {
+		if Q.Contains(w) && c < cost[w] {
+			cost[w] = c
+			Q.Fix(w)
+			parent[w] = v
+		}
+		return
+	}
 	for Q.Len() > 0 {
-		v := Q.Pop()
-		g.Visit(v, func(w int, c int64) (skip bool) {
-			if Q.Contains(w) && c < cost[w] {
-				cost[w] = c
-				Q.Fix(w)
-				parent[w] = v
-			}
-			return
-		})
+		v = Q.Pop()
+		g.Visit(v, do)
 	}
 	return
 }

mst_test.go

@@ -34,6 +34,7 @@ func TestMST(t *testing.T) {
 
 func BenchmarkMST(b *testing.B) {
 	n := 1000
+	b.ReportAllocs()
 	b.StopTimer()
 	g := New(n)
 	for i := 0; i < 2*n; i++ {