Python 如何在mpi4py的不同时间发送不同的邮件

我正在尝试用mpi4py实现一个区块链，我的结构如下： 1根，负责链，给出散列并将块输入链，一组验证器，检查素数并将其发送给各自的统一器，统一器将素数添加到块并发送给根，以便将其添加到链中。每个统一器有两个验证器 因此，我在节点之间发送信息时遇到了问题。 以下是我到目前为止的代码： 这里我得到了输入

import math as m
from mpi4py import MPI
import numpy as np
import sys
import hashlib
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size=comm.size
Nprimos=int(sys.argv[1])
k=int(sys.argv[2])

现在我定义了我的区块链和主要检测功能：

class Cadena:
    def __init__(self):
        self.cadena=[self.crearBloqueGenerador()]
        self.bloquesPendientes=[]

    def crearBloqueGenerador(self):
        generador = Bloque("0","Bloque Inicial")
        return generador 

    def getUltimoBloque(self):
        bloque=self.cadena[len(self.cadena)-1]
        return bloque

    def addBloque(self):
        for b in self.bloquesPendientes:
            nuevo = Bloque(b.primos,self.getUltimoBloque().hash)
            nuevo.hash=nuevo.calcularHash()
            self.cadena.append(nuevo)
        self.bloquesPendientes=[]
    def mostrarCadena(self):
        for b in self.cadena:
            print("Hash: ",b.hash)
            print("Comodin: ",b.comodin)
            print("Hash anterior: ",b.hashAnterior)
            print("Primos: " ,b.primos)

    def mostrarBloquesPendientes(self):
        for b in self.bloquesPendientes:
            print(b.hash)
            print(b.hashAnterior)
            print(b.primos)

class Bloque:

    def __init__(self,primos,hashAnterior="",comodin=0):
        self.primos=np.array(primos)
        self.hashAnterior= hashAnterior
        self.hash=hash
        self.comodin=0

    def __repr__(self):
        return  str(np.array(self.primos))

    def agregarPrimo(self,num):
        self.primos=np.append(self.primos,num)

    def calcularHash(self):
        dificultad="11"
        while dificultad!="00":
            self.comodin=self.comodin+1
            junto=str(self.hashAnterior)+str(self.primos)+str(self.comodin)
            hash=hashlib.sha256(junto.encode('utf-8')).hexdigest()
            dificultad=hash[:2]

        return  hash

def isPrime(n):
    sw = True
    if(n < 2): return False
    j = 2
    while( j <=np.sqrt(n) and sw):
        if n% j == 0:
            sw = False
        j+=1
    return sw 

卡德纳级：
定义初始化（自）：
self.cadena=[self.crearBloqueGenerador（）]
self.bloquesPendientes=[]
def crearBloqueGenerador（自身）：
generador=Bloque（“0”，“Bloque Inicial”）
返回将军
def getUltimoBloque（自）：
bloque=self.cadena[len（self.cadena）-1]
返回斑点
def addBloque（自身）：
对于self.bloquespendients中的b：
nuevo=Bloque（b.primos，self.getUltimoBloque（）.hash）
nuevo.hash=nuevo.calcularHash（）
self.cadena.append（新潮）
self.bloquesPendientes=[]
def莫斯特拉卡德纳（自身）：
对于self.cadena中的b：
打印（“哈希：”，b.Hash）
打印（“Comodin:”，b.Comodin）
打印（“哈希前：”，b.hashprevious）
打印（“Primos:”，b.Primos）
def mostrarBloquesPendientes（自我）：
对于self.bloquespendients中的b：
打印（b.hash）
印刷品（b.1）
印刷品（b.primos）
类Bloque：
定义初始值（self，primos，hashpreterior=“”，comodin=0）：
self.primos=np.array（primos）
self.hashfrontial=hashfrontial
self.hash=hash
self.comodin=0
定义报告（自我）：
返回str（np.array（self.primos））
def agregarPrimo（自我，数字）：
self.primos=np.append（self.primos，num）
def calcularHash（自身）：
deficultad=“11”
而困难="00":
self.comodin=self.comodin+1
junto=str（self.hashs）+str（self.primos）+str（self.comodin）
hash=hashlib.sha256（junto.encode（'utf-8'））.hexdigest（）
deficultad=hash[：2]
返回散列
def iPrime（n）：
sw=真
如果（n<2）：返回False
j=2
while（j
finished = False
paquetes=0
if rank==0:
    blockChain = Cadena()
    m=np.arange(0,Nprimos,1).reshape(int(Nprimos/k),k)
    print (m)
    comm.barrier()
    PendingHashes=np.zeros(size)
    workingOnPrimes=np.zeros(size)

    while finished ==False:
        for i in range(1,size):
            print("se supone que envio el paquete ",i)
            if workingOnPrimes[i]!=1 and i%3!=0:
                print("entro")
                comm.send(m[paquetes],Destino=i,tag=1)
                print("envio")
                paquetes+=1
                print("Package sent to ",i)
        for i in range(1,size):
            workingOnPrimes[i]= comm.recv(fuente=i,tag=3)
        print(workingOnPrimes)
        for i in range(1,size):
            PendingHashes[i]= comm.recv(fuente=i,tag=2)
        for i in range(1,size):
            if PendingHashes[i]==1:
                comm.send(blockChain.getUltimoBloque().hash,Destino=i,tag=0)
                print("Se le envio hash al nodo ",i)
        if (paquetes+1)*k>=Nprimos:
            finished=True
            comm.bcast(finished,root=0)
            blockChain.mostrarCadena()



if rank%3==1:
    unificador=rank+2
    comm.barrier()
    while finished==False:
        print(rank)
        seccion=comm.recv(source=0,tag=1)
        comm.send(data=int(0),dest=0,tag=3)

        for s in seccion:
            if isPrime(s):
                comm.send(s,unificador,tag=0)
                print("envie ",s," a ",unificador)

if rank%3==2:
    unificador=rank+1
    comm.barrier()
    while finished==False:
        comm.send(data=int(0),dest=0,tag=3)
        seccion=comm.recv(source=0,tag=1)
        for s in seccion:
            if isPrime(s):
                comm.send(s,unificador,tag=0)

if rank%3==0 and rank!=0:
    verificador1=rank-2
    verificador2=rank-1
    comm.barrier()
    while finished==False:

        primosAgregados=0
        primos=[]
        while primosAgregados<k:
            primo1=comm.recv(verificador1,tag=0)
            primos.append(primo1)
            primosAgregados+=1
            if primosAgregados==k:
                break
            primo2=comm.recv(verificador2,tag=0)
            primos.append(primo2)
            primosAgregados+=1
        comm.send(1,0,tag=2)
        lastHash=comm.recv(0,tag=0)
        bloque=Bloque(primos,lastHash)
        blockChain.bloquesPendientes.append(bloque)