benchmark woa wsl arm64 go

code

利用比特币的pow算法的简易版本对woa arm64 与 woa wsl arm64 版本的go进行benchmark测试

源码随便从网上摘的，这个东西学习过比特币区块链的人都写过，大同小异。

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"math/big"
	"strconv"
	"time"
)


type Block struct {
	LastHash  string //上一区块的哈希
	Hash      string //本区块的哈希值
	Data      string //数据
	TimeStamp string //时间戳
	Height    int    //区块高度
	Nonce     int64  //随机数
	DiffNum   uint   //难度值
}

// 难度值
var diffNum uint = 17


var blockchain []Block

// 挖矿函数即工作量证明算法
// 1.通过增大随机数的值 寻找适合的哈希值
// 2.类比比特币 寻找小于目标难度的哈希值
// 工作量证明算法的本质就是暴力求值 循环比较 直至找到符合要求的哈希值
func mine(data string) Block {
	// 定义区块
	if len(blockchain) < 1 {
		fmt.Println("没有区块头")
	}
	// 获取链上的最后一个区块
	lastBlock := blockchain[len(blockchain)-1]
	// 定义一个新的区块
	newBlock := new(Block)
	newBlock.LastHash = lastBlock.Hash
	newBlock.TimeStamp = time.Now().String()
	newBlock.Height = lastBlock.Height + 1
	newBlock.DiffNum = diffNum
	newBlock.Data = data
	var nonce int64 = 0
	newBigInt := big.NewInt(1)
	newBigInt.Lsh(newBigInt, 256-diffNum) // 相当于1 左移256-diffNum

	// 暴力计算
	for {
		newBlock.Nonce = nonce
		newBlock.getHash()
		hashInt := big.Int{}
		hashBytes, _ := hex.DecodeString(newBlock.Hash)
		hashInt.SetBytes(hashBytes) //将区块哈希值转大数字

		// 寻找合适的值
		// 比较x和y的大小。x<y时返回-1；x>y时返回+1；否则返回0
		if hashInt.Cmp(newBigInt) == -1 {
			break
		} else {
			nonce++ //递增随机数 直到找到合适的哈希值
		}
	}
	return *newBlock
}

func (b *Block) serialize() []byte {
	bytes, err := json.Marshal(b)
	if err != nil {
		log.Panic(err)
	}
	return bytes
}

func (b *Block) getHash() {
	result := sha256.Sum256(b.serialize())
	b.Hash = hex.EncodeToString(result[:])
}

func BlockChain() {
	genesisBlock := &Block{
		TimeStamp: time.Now().String(),
		Data:      "创世区块",
		LastHash:  "0000000000000000000000000000000000000000000000000000000000000000",
		Height:    1,
		Nonce:     0,
		DiffNum:   0,
	}
	genesisBlock.getHash()
	blockchain = append(blockchain, *genesisBlock)
	for i := 0; i < 100; i++ {
		newBlock := mine("记录一笔账" + strconv.Itoa(i))
		blockchain = append(blockchain, newBlock)
	}
}

package main

import (
	"testing"
)

func BenchmarkName(b *testing.B) {
	for i := 0; i < b.N; i++ {
		BlockChain()
	}
}

woa

PS ..\testgo\testpow> go test -benchmem -run=^$ -bench ^BenchmarkName$
goos: windows
goarch: arm64
pkg: testgo/testpow
BenchmarkName-8                1        32331706200 ns/op   7132080496 B/op 65533648 allocs/op
PASS
ok      testarmgo/testpow       32.374s

32331706200 ns/op

woa wsl

ophelia@Ophelia:~/goworkspace/testgo/testpow$ go test -benchmem -run=^$ -bench ^BenchmarkName$ 
goos: linux
goarch: arm64
pkg: testgo/testpow
BenchmarkName-8                1        14816995747 ns/op       8185443888 B/op 72533773 allocs/op
PASS
ok      testgo/testpow  14.821s

14816995747 ns/op < 32331706200 ns/op

单从以上测试可见，windows on arm 的 arm64原生go程序效率要低于 windows on arm 的 window subsystem for linux 的 arm64原生go程序。但该测试不代表普遍现象。仅供参考。