nirui/go_benchmark_map_vs_slice_access.go

## go_benchmark_map_vs_slice_access.go
package main

import (
	"fmt"
	"time"
)

type s struct {
	s []sData
}

type sData struct {
	NextIndex int
}

type m struct {
	m map[int]mData
}

type mData struct {
	NextKey int
}

const (
	testLevel = 1000000
	testTimes = 300
)

func buildS() *s {
	root := &s{
		s: make([]sData, testLevel),
	}
	half := testLevel / 2

	for k := range root.s {
		if k >= half {
			root.s[k] = sData{
				NextIndex: testLevel - k,
			}

			continue
		}

		root.s[k] = sData{
			NextIndex: testLevel - (k + 1),
		}
	}

	return root
}

func traverseS(t *s) int {
	levels := 0
	nextIndex := t.s[0].NextIndex

	for {
		if t.s[nextIndex].NextIndex == nextIndex {
			return levels
		}

		nextIndex = t.s[nextIndex].NextIndex
		levels++
	}
}

func buildM() *m {
	root := &m{
		m: make(map[int]mData, testLevel),
	}

	for i := 0; i < testLevel; i++ {
		root.m[i] = mData{
			NextKey: i + 1,
		}
	}

	return root
}

func traverseM(t *m) int {
	levels := 0
	nextKey := t.m[0].NextKey

	for {
		current, found := t.m[nextKey]

		if !found || current.NextKey == testLevel {
			return levels
		}

		nextKey = current.NextKey
		levels++
	}
}

func main() {
	fmt.Println("Building")

	sss := buildS()
	mmm := buildM()

	fmt.Println("Traversing")

	for i := 0; i < testTimes; i++ {
		start := time.Now()

		sCount := traverseS(sss)
		sEnd := time.Since(start)

		start = time.Now()
		mCount := traverseM(mmm)
		mEnd := time.Since(start)

		if sCount != mCount {
			panic("Count are different")
		}

		fmt.Printf("Traverse took: Slice %s vs Map %s\r\n", sEnd, mEnd)
	}
}
	package main

	import (
	"fmt"
	"time"
	)

	type s struct {
	s []sData
	}

	type sData struct {
	NextIndex int
	}

	type m struct {
	m map[int]mData
	}

	type mData struct {
	NextKey int
	}

	const (
	testLevel = 1000000
	testTimes = 300
	)

	func buildS() *s {
	root := &s{
	s: make([]sData, testLevel),
	}
	half := testLevel / 2

	for k := range root.s {
	if k >= half {
	root.s[k] = sData{
	NextIndex: testLevel - k,
	}

	continue
	}

	root.s[k] = sData{
	NextIndex: testLevel - (k + 1),
	}
	}

	return root
	}

	func traverseS(t *s) int {
	levels := 0
	nextIndex := t.s[0].NextIndex

	for {
	if t.s[nextIndex].NextIndex == nextIndex {
	return levels
	}

	nextIndex = t.s[nextIndex].NextIndex
	levels++
	}
	}

	func buildM() *m {
	root := &m{
	m: make(map[int]mData, testLevel),
	}

	for i := 0; i < testLevel; i++ {
	root.m[i] = mData{
	NextKey: i + 1,
	}
	}

	return root
	}

	func traverseM(t *m) int {
	levels := 0
	nextKey := t.m[0].NextKey

	for {
	current, found := t.m[nextKey]

	if !found \|\| current.NextKey == testLevel {
	return levels
	}

	nextKey = current.NextKey
	levels++
	}
	}

	func main() {
	fmt.Println("Building")

	sss := buildS()
	mmm := buildM()

	fmt.Println("Traversing")

	for i := 0; i < testTimes; i++ {
	start := time.Now()

	sCount := traverseS(sss)
	sEnd := time.Since(start)

	start = time.Now()
	mCount := traverseM(mmm)
	mEnd := time.Since(start)

	if sCount != mCount {
	panic("Count are different")
	}

	fmt.Printf("Traverse took: Slice %s vs Map %s\r\n", sEnd, mEnd)
	}
	}