我正在尝试用 python 编写一个简单的工作量证明 nonce-finder。

def proof_of_work(b, nBytes):
    nonce = 0
    # while the first nBytes of hash(b + nonce) are not 0
    while sha256(b + uint2bytes(nonce))[:nBytes] != bytes(nBytes):
        nonce = nonce + 1
    return nonce

现在我正在尝试进行多进程处理，因此它可以使用所有 CPU 内核并更快地找到随机数。我的想法是使用 multiprocessing.Pool 并多次执行函数 proof_of_work，传递两个参数 num_of_cpus_running 和 this_cpu_id，如下所示:

def proof_of_work(b, nBytes, num_of_cpus_running, this_cpu_id):
    nonce = this_cpu_id
    while sha256(b + uint2bytes(nonce))[:nBytes] != bytes(nBytes):
        nonce = nonce + num_of_cpus_running
    return nonce

所以，如果有 4 个核，每个核都会这样计算 nonce:

core 0: 0, 4, 8, 16, 32 ...
core 1: 1, 5, 9, 17, 33 ...
core 2: 2, 6, 10, 18, 34 ...
core 3: 3, 7, 15, 31, 38 ...

因此，我必须重写 proof_of_work，这样当任何进程找到一个 nonce 时，其他所有人都会停止寻找 nonce，考虑到找到的 nonce 必须是可能的最低值所需字节为 0。如果 CPU 由于某种原因加速，并返回一个高于最低有效随机数的有效随机数，则工作量证明无效。

我唯一不知道该怎么做的部分是，如果进程 B 发现一个随机数低于进程 A 现在正在计算的随机数，那么进程 A 只会停止。如果它更高，A一直计算(以防万一)，直到到达B提供的随机数。

我希望我的解释是正确的。另外，如果我写的任何东西有更快的实现，我很想听听。非常感谢!

最佳答案

一个简单的选择是使用微批处理并检查是否找到了答案。太小的批处理会导致启动并行作业的开销，太大会导致其他进程做额外的工作，而一个进程已经找到了答案。每批应该需要 1 - 10 秒才能有效。

示例代码:

from multiprocessing import Pool
from hashlib import sha256
from time import time


def find_solution(args):
    salt, nBytes, nonce_range = args
    target = '0' * nBytes

    for nonce in xrange(nonce_range[0], nonce_range[1]):
        result = sha256(salt + str(nonce)).hexdigest()

        #print('%s %s vs %s' % (result, result[:nBytes], target)); sleep(0.1)

        if result[:nBytes] == target:
            return (nonce, result)

    return None


def proof_of_work(salt, nBytes):
    n_processes = 8
    batch_size = int(2.5e5)
    pool = Pool(n_processes)

    nonce = 0

    while True:
        nonce_ranges = [
            (nonce + i * batch_size, nonce + (i+1) * batch_size)
            for i in range(n_processes)
        ]

        params = [
            (salt, nBytes, nonce_range) for nonce_range in nonce_ranges
        ]

        # Single-process search:
        #solutions = map(find_solution, params)

        # Multi-process search:
        solutions = pool.map(find_solution, params)

        print('Searched %d to %d' % (nonce_ranges[0][0], nonce_ranges[-1][1]-1))

        # Find non-None results
        solutions = filter(None, solutions)

        if solutions:
            return solutions

        nonce += n_processes * batch_size


if __name__ == '__main__':
    start = time()
    solutions = proof_of_work('abc', 6)
    print('\n'.join('%d => %s' % s for s in solutions))
    print('Solution found in %.3f seconds' % (time() - start))

输出(配备 Core i7 的笔记本电脑):

Searched 0 to 1999999
Searched 2000000 to 3999999
Searched 4000000 to 5999999
Searched 6000000 to 7999999
Searched 8000000 to 9999999
Searched 10000000 to 11999999
Searched 12000000 to 13999999
Searched 14000000 to 15999999
Searched 16000000 to 17999999
Searched 18000000 to 19999999
Searched 20000000 to 21999999
Searched 22000000 to 23999999
Searched 24000000 to 25999999
Searched 26000000 to 27999999
Searched 28000000 to 29999999
Searched 30000000 to 31999999
Searched 32000000 to 33999999
Searched 34000000 to 35999999
Searched 36000000 to 37999999
37196346 => 000000f4c9aee9d427dc94316fd49192a07f1aeca52f6b7c3bb76be10c5adf4d
Solution found in 20.536 seconds

单核耗时 76.468 秒。无论如何，这不是迄今为止找到解决方案的最有效方法，但它确实有效。例如，如果 salt 很长，则可以在盐被吸收后预先计算 SHA-256 状态，并从那里继续进行强力搜索。此外，字节数组可能比 hexdigest() 更高效。

关于当一个返回结果时，Python 停止多个进程？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32538001/