标签: distributed-computing

我最近读了很多关于拜占庭容错的论文。有一个常见的证明，需要 3m+1 台计算机来处理 m 个拜占庭故障。一般证明是这样的：

存在三个“将军”：A、B、C。假设将军们是这样沟通的，其中C是“叛徒”：

A --> B "Attack", A --> C "Attack"
B --> A "Attack", B --> C "Attack"
C --> A "Attack", C --> B "Retreat"

A receives "Attack" from both sources, and will attack.
B receives "Attack" from A but "Retreat" from C and doesn't know what to do.
C is a traitor, so his action could be anything.

因此，我们不能保证大多数参与者会达成共识。

我有点理解这个证明，但似乎忽略了一个要点。A、B、C不也各自内部计算着要做什么吗？由于A和B是这里的“忠诚”将军，因此似乎“正确”的行动是进攻。难道B在决定做什么时不允许考虑他自己的计算吗？在这种情况下，他可以轻松打破相互冲突的 A&C 输入之间的联系并决定进攻。然后，A和B都进攻，问题就解决了。这是一个与经典的拜占庭将军问题不同的问题吗？

所以我是 ZeroMQ 的新手，我正在尝试使用 ZeroMQ 发送字节消息PUB / SUB设置使用 ZeroMQ 发送字节消息。

编程语言的选择对于这个问题并不重要，因为我使用 ZeroMQ 进行多种语言之间的通信。

这是我的服务器代码：

import zmq
import time

port = "5556"
context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://*:%s" % port)
while True:
    socket.send(b'\x84\xa5Title\xa2hi\xa1y\xcb\x00\x00\x00\x00\x00\x00\x00\x00\xa1x\xcb@\x1c\x00\x00\x00\x00\x00\x00\xa4Data\x08')
    time.sleep(1)

这是我的 python 客户端代码：

import zmq

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://localhost:5556")

total_value = 0
for update_nbr in range (5):
    string = socket.recv()
    print (string)

我的客户只是阻止string = socket.recv()。

我已经做了一些研究，所以显然，如果我要使用PUB / SUB设置发送字符串，我需要设置一些“主题过滤器”才能使其工作。但如果我要发送一些字节消息，我不确定该怎么做。

我正在阅读一致性模型，但似乎无法理解分布式系统中因果关系的概念。我用谷歌搜索了很多，但没有找到这个概念的很好的解释。人们通常会解释为什么因果关系是个好东西，但基本概念是什么？

我想确认我对 Kademlia DHT 中的存储桶的理解。\nKademlia 有m 个 k 存储桶，其中m是网络的大小（以位为单位），k是每个存储桶存储的键值对的数量。\nm=4例如，让我们说我们可以有2^4节点，即从 0 到 15。

+========+\n| NodeId |\n+========+\n|   0000 |\n+--------+\n|   0001 |\n+--------+\n|   0010 |\n+--------+\n|   0011 |\n+--------+\n|   0100 |\n+--------+\n|   0101 |\n+--------+\n|   0110 |\n+--------+\n|   0111 |\n+--------+\n|   1000 |\n+--------+\n|   1001 |\n+--------+\n|   1010 |\n+--------+\n|   1011 |\n+--------+\n|   1100 |\n+--------+\n|   1101 |\n+--------+\n|   1110 |\n+--------+\n|   1111 |\n+--------+\n

每个节点都有0位匹配、1位匹配、2位匹配等的路由表，这就是m桶。此外，对于每个桶，它将存储k代表而不是单个 NodeId。\n因此，如果我们说 k=2，则节点 0101 的路由表将类似于：

\xe2\x94\x8c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x90\n\xe2\x94\x82         0101         \xe2\x94\x82\n\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4\n|                      |\n| +==================+ |\n| |       xxxx       | |\n| +==================+ …

我最近对将分布式训练纳入我的 Tensorflow 项目感兴趣。我正在使用 Google Colab 和 Python 3 来实现具有自定义分布式训练循环的神经网络，如本指南所述： https: //www.tensorflow.org/tutorials/distribute/training_loops

在该指南的“创建分配变量和图形的策略”部分下，有一些代码的图片，这些代码基本上设置了“MirroredStrategy”，然后打印生成的模型副本的数量，请参见下文。

控制台输出

据我了解，输出表明 MirroredStrategy 仅创建了模型的一个副本，因此仅使用一个 GPU 来训练模型。我的问题：Google Colab 是否仅限于在单个 GPU 上进行训练？

我尝试过在使用和不使用 GPU 加速的情况下调用 MirroredStrategy()，但每次都只获得一个模型副本。这有点令人惊讶，因为当我在 Python 中使用多处理包时，我得到了四个线程。因此，我预计可以在 Google Colab 中并行训练四个模型。Tensorflows 实现分布式训练是否存在问题？

我曾经在一次采访中被问到，如何处理消息队列中无序传入的消息。已经有一段时间了，我还没有找到明确的答案，我想知道该领域的专家是否可以帮助我回答这个问题，以满足我自己的好奇心。

据我了解，某些消息队列提供一次性和 FIFO 保证。我还知道流系统中事件时间和处理时间的概念。例如，在像 Kafka 这样的基于日志的消息队列中，由于偏移量和消息持久性的存在，混合排序可能不太可能发生（我可能是错的）。我还考虑过使用时间戳，要求每个消息发送者在发送之前记录消息的时间，但由于时钟偏差，这充满了不一致。

考虑到所有这些，我想知道如何解决 AMQP、JMS 或 RabbitMQ 等传统消息传递系统中的混合排序问题，其中十几个物联网设备可能正在发送消息，而我作为消费者希望以正确的顺序协调它们。

根据我的理解，领导者向追随者发送 AppendEntries RPC，如果大多数追随者返回成功，领导者将提交此条目。它会通过将其应用到自己的状态机来提交此条目，并且还会返回给客户端，让客户端知道该命令已成功。

然而，目前，追随者还不知道这一承诺。它将在下一个 AppendEntries（或心跳）RPC 调用中通知关注者。

在最简单的情况下，如果leader在提交之后、下一个AppendEntries之前崩溃，raft将使用“只有最新的follower才能获胜”策略来确保下一个leader必须包含这个日志条目（尽管没有提交），新的领导者将提交该条目并将 AppendEntries 发送给其他追随者。这样，日志条目就可以安全保存。

然而，请考虑以下复杂的场景（摘自博士论文“共识：理论与实践的桥梁”第 23 页）。

此时，第 2 项的日志条目已复制到大多数服务器上，但尚未提交。如果 S1 如 (d1) 那样崩溃，S5 可以当选为领导者（通过 S2、S3 和 S4 的投票）并用第 3 期中自己的条目覆盖该条目。

如果此时在服务器 S1 中已提交，但在其他服务器中尚未提交怎么办？如果 S1 然后像 (d1) 那样崩溃，该日志条目将被 S5 覆盖吗？

根据我的理解，提交的条目（应用于状态机并可能通知客户端结果）永远不会被覆盖？

我是否误解了筏协议的任何内容？

谢谢。

假设我有一个 celery 任务，它需要两个参数： X(a,b)

我需要使用以下两个规则来实现自定义并发逻辑：

1. X如果 的实例具有不同的 值，则它们可以同时运行a。也就是说，如果X(a=1,b=10)正在运行时X(a=2,b=20)被加入队列，则后者被从队列中拉出并立即执行。

2. 如果 的实例X具有相同的 值，则它们不能同时运行a。也就是说，如果X(a=1,b=10)正在运行时X(a=1,b=20)被添加到队列中，那么后者必须在队列中等待，直到前者完成。

规则 #1 通过设置worker_concurrency>1( docs )与 celery 一起开箱即用。规则#2 是棘手的。

如文档和本博客中所述，分布式任务锁定是一种使我接近所需的方法。甚至还有一些库可以为您实现它（celery-singleton）。然而，回顾规则#2，这种方法似乎可以防止第二个任务排队，直到第一个任务完成。我需要它排队，只是在第一个任务完成之前不在工作人员上执行。

无论如何要实现这个吗？This SO question问了一个类似的问题，但到目前为止还没有答案。

我想要（正确且官方的无错误方式）执行以下操作：

\n
1. 从检查点恢复以继续在多个 GPU 上进行训练
\n
2. 在使用多个 GPU 进行训练期间正确保存检查点
\n

为此，我的猜测如下：

\n
1. 为了执行第 1 步，我们让所有进程从文件中加载检查点，然后调用DDP(mdl)每个进程。我假设检查点保存了一个ddp_mdl.module.state_dict().
\n
2. 要做2，只需检查谁的rank = 0并让其执行torch.save({\'model\': ddp_mdl.module.state_dict()})
\n

大概代码：

def save_ckpt(rank, ddp_model, path):\n    if rank == 0:\n        state = {\'model\': ddp_model.module.state_dict(),\n             \'optimizer\': optimizer.state_dict(),\n            }\n        torch.save(state, path)\n\ndef load_ckpt(path, distributed, map_location=map_location=torch.device(\'cpu\')):\n    # loads to\n    checkpoint = torch.load(path, map_location=map_location)\n    model = Net(...)\n    optimizer = ...\n    model.load_state_dict(checkpoint[\'model\'])\n    optimizer.load_state_dict(checkpoint[\'optimizer\'])\n    if distributed:\n        model = DDP(model, device_ids=[gpu], find_unused_parameters=True)\n    return model\n

它是否正确？

我问的原因之一是分布式代码可能会出现微妙的错误。我想确保这不会发生在我身上。当然，我想避免死锁，但如果它发生在我身上，那就很明显了（例如，如果所有进程以某种方式尝试同时打开同一个 …

我的情况如下-我有一个带有函数foo（）的客户端C，它执行一些计算。

我希望不知道foo（）的服务器S执行此功能，然后将结果发送回客户端。

我正在尝试确定在Erlang中执行此操作的最佳方法。我正在考虑：

• 热代码交换-即S中的“升级”代码，使其具有功能foo（）。执行并发送回客户端。
• 在所有节点都被适当注册的分布式方式中，沿着S的方向做点事情！C：foo（） -为了“发送”功能到进程/节点S

我还没有想到其他方法（或语言的功能）吗？

谢谢您的帮助！