Add single thread matrix multiplication algorithms and corresponding tests and benchmarks

Add a int set implementation and its test
Add a permutation implementation making use of above int set and corresponding test

Author: zhaih

bench/benchMatOps_test.go

@@ -0,0 +1,55 @@
+package bench
+
+import (
+	"algo/math"
+	"testhelper"
+	"testing"
+)
+
+const test_size = 500
+
+/*
+ Test result when ma and mb are both 5000 x 5000 matrix
+ goos: windows
+ goarch: amd64
+ BenchmarkMatMulSlow-8       	       1	2114916672000 ns/op
+ BenchmarkMatMulTiling16-8   	       1	362979711200 ns/op
+ BenchmarkMatMulTiling24-8   	       1	373598301500 ns/op
+ BenchmarkMatMulTiling32-8   	       1	376010471000 ns/op
+*/
+
+func BenchmarkMatMulSlow(b *testing.B) {
+	ma := testhelper.GenMat(test_size, test_size, 1)
+	mb := testhelper.GenMat(test_size, test_size, 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		math.MatmulSlow(ma, mb)
+	}
+}
+
+func BenchmarkMatMulTiling16(b *testing.B) {
+	ma := testhelper.GenMat(test_size, test_size, 1)
+	mb := testhelper.GenMat(test_size, test_size, 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		math.MatmulTiling(ma, mb, 16)
+	}
+}
+
+func BenchmarkMatMulTiling24(b *testing.B) {
+	ma := testhelper.GenMat(test_size, test_size, 1)
+	mb := testhelper.GenMat(test_size, test_size, 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		math.MatmulTiling(ma, mb, 24)
+	}
+}
+
+func BenchmarkMatMulTiling32(b *testing.B) {
+	ma := testhelper.GenMat(test_size, test_size, 1)
+	mb := testhelper.GenMat(test_size, test_size, 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		math.MatmulTiling(ma, mb, 32)
+	}
+}

bench/benchParaReduce_test.go bench/benchReduce_test.gobench/benchParaReduce_test.go renamed to bench/benchReduce_test.go

@@ -0,0 +1,30 @@
+package back_track
+
+import "data"
+
+func Permutation(ary []int) [][]int {
+	is := data.IntSet{}
+	is.Init(ary)
+	ret := make([][]int, 0)
+
+	var next func([]int)
+	next = func(r []int) {
+		if is.Size() == 1 {
+			r = append(r, is.Get())
+			ret = append(ret, r)
+			return
+		}
+		s := is.Size()
+		for i := 0; i < s; i++ {
+			x := is.Get()
+			is.Delete()
+			entry := make([]int, len(r)+1)
+			copy(entry, r)
+			entry[len(r)] = x
+			next(entry)
+			is.Insert(x)
+		}
+	}
+	next([]int{})
+	return ret
+}

bench/benchParaScan_test.go bench/benchScan_test.gobench/benchParaScan_test.go renamed to bench/benchScan_test.go

@@ -0,0 +1,48 @@
+package math
+
+// const tiling_size = 32
+// 32^2 = 1024, my cpu's l1 cache could store about 6400 int,
+// need store 3 matrix at the same time, so it should be a reasonable number
+
+// will not do error handling as it is not an actual ready-to-use function
+func MatmulSlow(ma, mb [][]int) [][]int {
+	if len(ma) == 0 || len(mb) == 0 || len(ma[0]) != len(mb) {
+		return nil
+	}
+
+	ret := make([][]int, len(ma))
+	for i := 0; i < len(ma); i++ {
+		ret[i] = make([]int, len(mb[0]))
+		for j := 0; j < len(mb[0]); j++ {
+			for k := 0; k < len(mb); k++ {
+				ret[i][j] += ma[i][k] * mb[k][j]
+			}
+		}
+	}
+	return ret
+}
+
+func MatmulTiling(ma, mb [][]int, t int) [][]int {
+	if len(ma) == 0 || len(mb) == 0 || len(ma[0]) != len(mb) {
+		return nil
+	}
+
+	ret := make([][]int, len(ma))
+	for i := 0; i < len(ret); i++ {
+		ret[i] = make([]int, len(mb[0]))
+	}
+	for i := 0; i < len(ret); i += t {
+		for j := 0; j < len(mb[0]); j += t {
+			for k := 0; k < len(mb); k += t {
+				for x := 0; x < t && (i+x) < len(ma); x++ {
+					for y := 0; y < t && (j+y) < len(mb[0]); y++ {
+						for z := 0; z < t && (k+z) < len(mb); z++ {
+							ret[i+x][j+y] += ma[i+x][k+z] * mb[k+z][j+y]
+						}
+					}
+				}
+			}
+		}
+	}
+	return ret
+}

src/algo/back_track/permutation.go

@@ -1,45 +1,8 @@
 package parallel
 
-import "sync"
-
 // basic parallel algorithms, scan and reduce
 // restrict to int operation to avoid using []interface{}
 
-type AtomicInt struct {
-	n    int
-	lock *sync.Mutex
-}
-
-func (x *AtomicInt) Init(n int) {
-	x.n = n
-	x.lock = &sync.Mutex{}
-}
-
-func (x *AtomicInt) Inc() {
-	x.lock.Lock()
-	x.n++
-	x.lock.Unlock()
-}
-
-func (x *AtomicInt) Set(n int) {
-	x.lock.Lock()
-	x.n = n
-	x.lock.Unlock()
-}
-
-func (x *AtomicInt) Dec() {
-	x.lock.Lock()
-	x.n++
-	x.lock.Unlock()
-}
-
-func (x *AtomicInt) Get() int {
-	x.lock.Lock()
-	v := x.n
-	x.lock.Unlock()
-	return v
-}
-
 const parallelThreshold = 2048
 
 func Reduce(ary []int, f func(int, int) int, init int) int {

src/algo/math/matrix.go

@@ -0,0 +1,112 @@
+package data
+
+type elem struct {
+	X          int
+	Prev, Next *elem
+}
+
+// implemented with double linked cycle list and hash map
+// Constant time add, remove, check
+// Iterable, and able to insert and delete easily while iterating
+type IntSet struct {
+	hm         map[int]*elem
+	head, curr *elem
+}
+
+func (s *IntSet) Init(ary []int) {
+	s.hm = make(map[int]*elem)
+	if ary == nil {
+		return
+	}
+	for _, n := range ary {
+		s.Add(n)
+	}
+}
+
+func (s *IntSet) Add(n int) {
+	if _, ok := s.hm[n]; !ok {
+		nn := &elem{
+			X:    n,
+			Prev: nil,
+			Next: nil,
+		}
+		s.hm[n] = nn
+		if s.head == nil {
+			s.head = nn
+			nn.Prev = nn
+			nn.Next = nn
+		} else {
+			s.head.Prev.Next = nn
+			nn.Prev = s.head.Prev
+			nn.Next = s.head
+			s.head.Prev = nn
+		}
+	}
+}
+
+func (s *IntSet) Contains(n int) bool {
+	_, ok := s.hm[n]
+	return ok
+}
+
+func (s *IntSet) Remove(n int) {
+	e, ok := s.hm[n]
+	if !ok {
+		return
+	}
+	if e.Next == e {
+		s.head = nil
+		s.curr = nil
+	} else {
+		if s.head == e {
+			s.head = e.Next
+		}
+		e.Next.Prev = e.Prev
+		e.Prev.Next = e.Next
+	}
+	delete(s.hm, n)
+}
+
+func (s *IntSet) Get() int {
+	if s.curr == nil {
+		s.curr = s.head
+	}
+	return s.curr.X
+}
+
+// return whether next s.Get() call is still within the same iteration
+func (s *IntSet) Next() bool {
+	if s.curr == nil {
+		s.curr = s.head
+	}
+	s.curr = s.curr.Next
+	return s.curr != s.head
+}
+
+// insert before s.curr
+func (s *IntSet) Insert(n int) {
+	if _, ok := s.hm[n]; !ok && s.curr != nil {
+		nn := &elem{
+			X:    n,
+			Prev: s.curr.Prev,
+			Next: s.curr,
+		}
+		s.hm[n] = nn
+		s.curr.Prev.Next = nn
+		s.curr.Prev = nn
+	}
+}
+
+// delete current element under s.curr and move it to next elem
+func (s *IntSet) Delete() {
+	if s.curr == nil {
+		return
+	}
+	v := s.curr.X
+	s.curr = s.curr.Next
+	s.Remove(v)
+}
+
+func (s *IntSet) Size() int {
+	return len(s.hm)
+}

src/algo/parallel/basic.go

@@ -0,0 +1,38 @@
+package data
+
+import "sync"
+
+type AtomicInt struct {
+	n    int
+	lock *sync.Mutex
+}
+
+func (x *AtomicInt) Init(n int) {
+	x.n = n
+	x.lock = &sync.Mutex{}
+}
+
+func (x *AtomicInt) Inc() {
+	x.lock.Lock()
+	x.n++
+	x.lock.Unlock()
+}
+
+func (x *AtomicInt) Set(n int) {
+	x.lock.Lock()
+	x.n = n
+	x.lock.Unlock()
+}
+
+func (x *AtomicInt) Dec() {
+	x.lock.Lock()
+	x.n++
+	x.lock.Unlock()
+}
+
+func (x *AtomicInt) Get() int {
+	x.lock.Lock()
+	v := x.n
+	x.lock.Unlock()
+	return v
+}

src/data/set.go

@@ -70,3 +70,23 @@ func BigInput(n int) []int {
 func Plus(a, b int) int {
 	return a + b
 }
+
+func GenMat(m, n, fill int) [][]int {
+	ret := make([][]int, m)
+	for i := 0; i < m; i++ {
+		ret[i] = make([]int, n)
+		for j := 0; j < n; j++ {
+			ret[i][j] = fill
+		}
+	}
+	return ret
+}
+
+func GenEyeMat(m int) [][]int {
+	ret := make([][]int, m)
+	for i := 0; i < m; i++ {
+		ret[i] = make([]int, m)
+		ret[i][i] = 1
+	}
+	return ret
+}