Hash 算法性能测试

CODE

package main

import (
	"crypto/md5"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	"fmt"
	quark "github.com/mycroft/goquarkhash"
	"golang.org/x/crypto/md4"
	"golang.org/x/crypto/sha3"
	"hash/crc32"
	"math/rand"
	"sort"
	"time"
)

type Int64Slice []int64

func (x Int64Slice) Len() int           { return len(x) }
func (x Int64Slice) Less(i, j int) bool { return x[i] < x[j] }
func (x Int64Slice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

var (
	mp        = make(map[int64]string)
	szAverage = Int64Slice{}
)

func init() {
	rand.Seed(time.Now().UnixNano())
}

func randStr(length int) string {
	var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
	b := make([]rune, length)
	for i := range b {
		b[i] = letters[rand.Intn(len(letters))]
	}
	return string(b)
}

func calculateTime(name string, fn func()) {
	now := time.Now()
	count := 500000
	for i := 0; i < count; i++ {
		fn()
	}
	total := time.Now().Sub(now).Nanoseconds()
	average := total / int64(count)
	fmt.Printf("name:%s\tcount:%d\ttotal:%dns\taverage: %dns\n", name, count, total, average)

	szAverage = append(szAverage, average)
	mp[average] = name
}

func main() {
	input := []byte(randStr(256))
	calculateTime("quark", func() {
		_ = quark.QuarkHash(input)
	})
	calculateTime("sha512-512", func() {
		_ = sha512.Sum512(input)
	})
	calculateTime("sha512-384", func() {
		_ = sha512.Sum384(input)
	})
	calculateTime("sha512-256", func() {
		_ = sha512.Sum512_256(input)
	})
	calculateTime("sha512-224", func() {
		_ = sha512.Sum512_224(input)
	})
	calculateTime("sha256-256", func() {
		_ = sha256.Sum256(input)
	})
	calculateTime("sha256-224", func() {
		_ = sha256.Sum224(input)
	})
	calculateTime("sha1-160", func() {
		_ = sha1.Sum(input)
	})
	calculateTime("md5-128", func() {
		_ = md5.Sum(input)
	})
	calculateTime("md4", func() {
		h := md4.New()
		_ = h.Sum(input)
	})
	calculateTime("sha3-512", func() {
		h := sha3.New512()
		_ = h.Sum(input)
	})
	calculateTime("sha-384", func() {
		h := sha3.New384()
		_ = h.Sum(input)
	})
	calculateTime("sha-256", func() {
		h := sha3.New256()
		_ = h.Sum(input)
	})
	calculateTime("sha-224", func() {
		h := sha3.New224()
		_ = h.Sum(input)
	})
	calculateTime("crc32-32", func() {
		_ = crc32.ChecksumIEEE(input)
	})

	sort.Sort(szAverage)
	fmt.Println("\n------------------sorted------------------")
	for _, average := range szAverage {
		fmt.Printf("name:%s\taverage:%dns\n", mp[average], average)
	}
}

RESULT

name:quark      count:500000    total:4035904900ns      average: 8071ns
name:sha512-512 count:500000    total:349247000ns       average: 698ns
name:sha512-384 count:500000    total:348408600ns       average: 696ns
name:sha512-256 count:500000    total:344548600ns       average: 689ns
name:sha512-224 count:500000    total:345009900ns       average: 690ns
name:sha256-256 count:500000    total:418285600ns       average: 836ns
name:sha256-224 count:500000    total:414991700ns       average: 829ns
name:sha1-160   count:500000    total:237341500ns       average: 474ns
name:md5-128    count:500000    total:209042900ns       average: 418ns
name:md4        count:500000    total:157098900ns       average: 314ns
name:sha3-512   count:500000    total:390653200ns       average: 781ns
name:sha-384    count:500000    total:412159200ns       average: 824ns
name:sha-256    count:500000    total:423354200ns       average: 846ns
name:sha-224    count:500000    total:411969200ns       average: 823ns
name:crc32-32   count:500000    total:8666200ns 		average: 17ns

------------------sorted------------------
name:crc32-32   average:17ns
name:md4        average:314ns
name:md5-128    average:418ns
name:sha1-160   average:474ns
name:sha512-256 average:689ns
name:sha512-224 average:690ns
name:sha512-384 average:696ns
name:sha512-512 average:698ns
name:sha3-512   average:781ns
name:sha-224    average:823ns
name:sha-384    average:824ns
name:sha256-224 average:829ns
name:sha256-256 average:836ns
name:sha-256    average:846ns
name:quark      average:8071ns