Function nonceGen

cmd/cql/internal/idminer.go:128–223

(publicKey *asymmetric.PublicKey)

}

func nonceGen(publicKey *asymmetric.PublicKey) *mine.NonceInfo {
	publicKeyBytes := publicKey.Serialize()

	cpuCount := runtime.NumCPU()
	ConsoleLog.Infof("cpu: %#v\n", cpuCount)
	stopCh := make(chan struct{})
	nonceCh := make(chan mine.NonceInfo, cpuCount)
	progressCh := make(chan int, 100)
	var wg sync.WaitGroup

	rand.Seed(time.Now().UnixNano())
	step := 256 / cpuCount
	for i := 0; i < cpuCount; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			startBit := i * step
			position := startBit / 64
			shift := uint(startBit % 64)
			ConsoleLog.Debugf("position: %#v, shift: %#v, i: %#v", position, shift, i)
			var start mine.Uint256
			if position == 0 {
				start = mine.Uint256{A: uint64(1<<shift) + uint64(rand.Uint32())}
			} else if position == 1 {
				start = mine.Uint256{B: uint64(1<<shift) + uint64(rand.Uint32())}
			} else if position == 2 {
				start = mine.Uint256{C: uint64(1<<shift) + uint64(rand.Uint32())}
			} else if position == 3 {
				start = mine.Uint256{D: uint64(1<<shift) + uint64(rand.Uint32())}
			}

			for j := start; ; j.Inc() {
				select {
				case <-stopCh:
					return
				default:
					currentHash := mine.HashBlock(publicKeyBytes, j)
					currentDifficulty := currentHash.Difficulty()
					progressCh <- currentDifficulty
					if currentDifficulty >= difficulty {
						nonce := mine.NonceInfo{
							Nonce:      j,
							Difficulty: currentDifficulty,
							Hash:       currentHash,
						}
						nonceCh <- nonce
						return
					}
				}
			}
		}(i)
	}

	wg.Add(1)
	go func() {
		defer wg.Done()
		var count, current int