Python Message.referenceId方法代码示例

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def signal(self, cv):
     self.log("INFO", "("+str(cv.id)+") signaling")
     cv.conditionVariable.acquire()
     sigmes = Message()
     sigmes.referenceId = cv.id
     sigmes.type = "SIGNAL"
     if len(cv.waitingProcesses) >0:
         sigmes.recipientId = cv.waitingProcesses[0]
         self.communicationManager.send_message(sigmes)
     cv.conditionVariable.release()

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def signal_all(self, cv):
     self.log("INFO", "("+str(cv.id)+") signaling to all")
     cv.conditionVariable.acquire()
     sigmes = Message()
     sigmes.referenceId = cv.id
     sigmes.type = "SIGNAL"
     for proc in cv.waitingProcesses:
         sigmes.recipientId = proc
         self.communicationManager.send_message(sigmes)
     cv.conditionVariable.release()

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def wait(self, cv, mux):
     cv.conditionVariable.acquire()
     cv.waiting = True
     retmes = Message()
     retmes.referenceId = cv.id
     retmes.type = "WAIT"
     self.communicationManager.send_broadcast(retmes)
     self.log("INFO", "("+str(cv.id)+")"+" waiting...")
     while cv.waiting:
         self.unlock(mux)
         cv.conditionVariable.wait()
         cv.conditionVariable.release()
         self.log("INFO", "("+str(cv.id)+") Reaquiring lock...")
         self.lock(mux)
     self.log("INFO", "("+str(cv.id)+") Received signal")
     retmes = Message()
     retmes.referenceId = cv.id
     retmes.type = "WAIT_RETURN"
     self.communicationManager.send_broadcast(retmes)

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def set_data_for_return(self, data, size):
     if self.previousReturn is not None:
         del self.previousReturn
     m = Message()
     m.type = "DATA"
     m.referenceId = self.id
     m.hasData = True
     m.dataSize = size
     m.data = data
     self.previousReturn = m

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def lock(self, mux):
     mux.operationMutex.acquire()
     mux.requesting = True       # set mux to wait for CS
     mux.keepAlive = False
     if mux.agreeVector is not None:     # reset agreeVector
         del mux.agreeVector
     mux.agreeVector = [False]*self.communicationManager.processCount      # agree vector init
     for i in range(0, self.communicationManager.processCount):
         mux.agreeVector[i] = (i == self.communicationManager.processId)     # set every entry to false except requesting process
     reqmes = Message()
     reqmes.type = "REQUEST"
     reqmes.referenceId = mux.id
     self.communicationManager.send_broadcast(reqmes)        # send requests to everybody
     mux.requestClock = reqmes.clock
     mux.locked = True
     mux.criticalSectionCondition.acquire()
     mux.operationMutex.release()
     while mux.requesting:
         mux.criticalSectionCondition.wait()
     mux.criticalSectionCondition.release()
     self.log("INFO", "("+str(mux.id)+") locked")

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def unlock(self, mux):
     mux.operationMutex.acquire()
     if not mux.locked:
         mux.operationMutex.release()
         return
     retmes = Message()
     retmes.type = "RETURN"
     retmes.referenceId = mux.id
     if len(mux.heldUpRequests) == 0:
         mux.keepAlive = True    # respond with RETURN instead of AGREE (after CS)
     for proc in mux.heldUpRequests:
         retmes.recipientId = proc
         self.communicationManager.send_message(retmes)
     del mux.heldUpRequests[:]
     mux.requesting = False
     mux.locked = False
     self.communicationManager.get_communication_mutex().acquire()  # create new agreeVector
     mux.agreeVector = dict()
     for i in range(0, self.communicationManager.processCount):
         mux.agreeVector[i] = (i == self.communicationManager.processId)     # set every entry to false except requesting process
     self.communicationManager.get_communication_mutex().release()
     mux.operationMutex.release()
     self.log("INFO", "("+str(mux.id)+") unlocked and leaving CS")

# 需要导入模块: from message import Message [as 别名]
# 或者: from message.Message import referenceId [as 别名]
 def communication_loop(self):
     while True:
         msg = self.communicationManager.recv_message()      # blocking
         if msg is None:
             break
         if msg.type == "REQUEST":    # requesting CS access
             mux = Mutex.get_mutex(msg.referenceId)
             if mux is not None:
                 mux.operationMutex.acquire()
                 if mux.requesting:        # if REQUEST has earlier time then send AGREE
                     if mux.requestClock < msg.clock:  # add to queue
                         mux.heldUpRequests.append(msg.senderId)
                     else:
                         if mux.requestClock == msg.clock and self.communicationManager.processId < msg.senderId:
                             mux.heldUpRequests.append(msg.senderId)
                         else:
                             agreeReply = Message()
                             agreeReply.referenceId = msg.referenceId
                             agreeReply.recipientId = msg.senderId
                             if mux.keepAlive:
                                 agreeReply.type = "RETURN"
                                 if mux.get_data_size() > 0:
                                     agreeReply.hasData = True
                             else:
                                 agreeReply.type = "AGREE"
                             self.communicationManager.send_message(agreeReply)
                 else:
                     if not mux.locked:
                         agreeReply = Message()
                         agreeReply.referenceId = msg.referenceId
                         agreeReply.recipientId = msg.senderId
                         if mux.keepAlive:
                             agreeReply.type = "RETURN"
                         else:
                             agreeReply.type = "AGREE"
                         self.communicationManager.send_message(agreeReply)
                     else:
                         mux.heldUpRequests.append(msg.senderId)
                 mux.operationMutex.release()
         elif msg.type == "RETURN":  # when leaving CS
             mux = Mutex.get_mutex(msg.referenceId)
             if mux is not None:
                 mux.operationMutex.acquire()
                 mux.agreeVector[msg.senderId] = True
                 mux.keepAlive = False
                 if mux.previousReturn is not None:
                     del mux.previousReturn
                 mux.previousReturn = msg
                 mux.operationMutex.release()
                 self.enter_critical_section(mux)
         elif msg.type == "AGREE":           # process agrees to request for CS
             mux = Mutex.get_mutex(msg.referenceId)
             mux.operationMutex.acquire()
             if mux is not None and mux.requesting:
                 mux.agreeVector[msg.senderId] = True       # sender agreed
                 mux.keepAlive = False                      # sb tries to acquire CS
                 mux.operationMutex.release()
                 self.enter_critical_section(mux)       # try to enter CS
             else:
                 mux.operationMutex.release()
         elif msg.type == "WAIT":        # process is waiting
             cv = ConditionVariable.get_condition_variable(msg.referenceId)
             cv.conditionVariable.acquire()
             cv.waitingProcesses.append(msg.senderId)
             cv.conditionVariable.release()
         elif msg.type == "WAIT_RETURN":     # process is not waiting anymore
             cv = ConditionVariable.get_condition_variable(msg.referenceId)
             cv.conditionVariable.acquire()
             cv.waitingProcesses.remove(msg.senderId)
             cv.conditionVariable.release()
         elif msg.type == "SIGNAL":          # wake up waiting process
             cv = ConditionVariable.get_condition_variable(msg.referenceId)
             cv.conditionVariable.acquire()
             cv.waiting = False
             cv.conditionVariable.notify()
             cv.conditionVariable.release()
         elif msg.type == "QUIT":            # process will no longer communicate
             self.quitMessages += 1
             if self.quitMessages == self.communicationManager.processCount:
                 self.communicationManager.initialized = False
                 return