标签: distributed-computing

我想使用一种技术,用于服务和数千个客户之间的通信.我开始了解WCF并阅读了一些相关内容.虽然它看起来很有吸引力并且没有互操作性问题,但我想知道其他可以提供与WCF相同功能的领先技术吗？那里有没有开源技术？另外,哪种技术应用最广泛？在我将自己投入WCF之前,我只想要这些信息.

编辑:作为WCF的替代,我的意思是说我正在寻找一个框架,将帮助我在Linux或任何其他平台上实现web服务.例如,wcf通过使用硬编码的.NET应用程序简化了创建Web服务的过程.同样,我需要一个linux工具.我遇到了单声道,但发现它不完整而且不太可靠.

据我所知,分片(例如在MongoDB中)和分布式文件系统(例如HBase或HyperTable中的HDFS)是数据库用于横向扩展的不同机制,但是我想知道它们如何比较？

我最近开始学习0MQ.今天早些时候,我遇到了一个博客,使用ZeroMQ进行Python多处理.它谈到了我读到的0MQ指南中的呼吸机模式,所以我决定尝试一下.

我决定尝试让呼吸机通过0mq消息向工作人员发送大型阵列,而不是像原始代码那样只计算工人的数字产品.以下是我用于" 实验 "的代码.

如下面的评论中所述,每当我尝试将变量string_length增加到大于3MB的数字时,代码就会挂起.

典型症状:假设我们将string_length设置为4MB(即4194304),然后结果管理器可能从一个worker获取结果,然后代码暂停.htop显示2个核心没有做太多.Etherape网络流量监视器也显示lo接口上没有流量.

到目前为止,经过几个小时的环顾四周,我无法弄清楚造成这种情况的原因,并且会对这个问题的原因和解决方案提出一两个暗示.谢谢!

我在配备Intel Core CPU,8GB RAM,80GB Intel X25MG2 SSD,Python 2.7.1 +,libzmq1 2.1.10-1chl1~natty1,python-pyzmq 2.1.10-1chl1~natty1的戴尔笔记本电脑上运行Ubuntu 11.04 64bit

import time
import zmq
from multiprocessing import Process, cpu_count

np = cpu_count() 
pool_size = np
number_of_elements = 128
# Odd, why once the slen is bumped to 3MB or above, the code hangs?
string_length = 1024 * 1024 * 3

def create_inputs(nelem, slen, pb=True):
    '''
    Generates an array that contains …

有NoSQL的ACID(分布式)数据库,尽管CAP定理.这怎么可能？CAP定理与(可能/不可能)成为ACID之间的关系是什么？

是不可能用于分布式计算机系统同时提供一致性,可用性和分区耐受性.

我最近读了很多关于拜占庭容错的论文。有一个常见的证明，需要 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都进攻，问题就解决了。这是一个与经典的拜占庭将军问题不同的问题吗？

我想确认我对 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 覆盖吗？

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

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

谢谢。

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

\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

它是否正确？

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