在已知的论文"一个故障过程的分布式共识的不可能性"(JACM85)中,FLP(Fisher,Lynch和Paterson)证明了令人惊讶的结果,即没有完全异步的共识协议甚至可以容忍一个未宣布的过程死亡.
在引理3中,在显示D包含0价和1价配置之后,它说:
如果一个邻居在一个步骤中产生结果,则调用两个配置邻居.通过简单的归纳,存在邻域C 0,C1∈C,使得D 6 = e(C 6)是i价,i = 0,1.
我可以按照整个证据,除非他们声称存在这样的C 0和C 1.你能给我一些提示吗?
我在Softlayer上有一个四节点Hadoop集群.主(NameNode)具有用于外部访问的公共IP地址和用于群集访问的专用IP地址.从节点(datanode)具有私有IP地址,我正在尝试连接到主节点,而无需为每个从节点分配公共IP地址.
我已经意识到设置fs.defaultFS为NameNode的公共地址允许外部访问,除了NameNode只侦听传入连接的地址,而不是私有地址.所以我在datanode日志中得到ConnectionRefused异常,因为他们试图连接NameNode的私有IP地址.
我认为解决方案可能是将公共和私有IP地址都设置为NameNode,以便保留外部访问并允许我的从属节点也连接.
那么有一种方法可以将这两个地址绑定到NameNode,以便它可以同时监听吗?
编辑:Hadoop版本2.4.1.
java hadoop network-programming distributed-computing cluster-computing
我在两台不同的机器上安装了两个GPU.我想构建一个集群,允许我通过一起使用两个GPU来学习Keras模型.
Keras博客在分布式培训部分显示两段代码并链接官方Tensorflow文档.
我的问题是我不知道如何学习我的模型,用Keras编写,使用Tensorflow文档实际描述了Tensorflow对象的过程.
例如,如果我想在多个GPU的集群上执行以下代码,我该怎么办?
# For a single-input model with 2 classes (binary classification):
model = Sequential()
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
# Generate dummy data
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))
# Train the model, iterating on the data in batches of 32 samples
model.fit(data, labels, epochs=10, batch_size=32)
Run Code Online (Sandbox Code Playgroud) 我打算编写一个具有分布式工作进程的应用程序.其中一个将是Leader,它将任务分配给其他进程.设计领导者选举过程非常简单:每个过程都尝试在同一路径中创建一个短暂的节点.无论谁成功,都会成为领导者.
现在,我的问题是如何设计均匀分配任务的过程?这个的任何食谱?
我将详细介绍一下环境设置:
假设有10个工人机器,每个机器运行一个过程,其中一个成为领导者.任务在队列中提交,领导者接收它们并分配给工作人员.每当提交任务时,工作进程都会收到通知.
我100 servers在我的集群中.
当时17:35:00,所有100 servers都提供了数据(大小1[MB]).每个服务器处理数据,并产生约的输出40[MB].每台服务器的处理时间是5[sec].
在time 17:35:05(5[sec] later),需要一台中央机器来读取所有输出100 servers(记住,数据的总大小是:100 [机器] x 40 [MB] ~4 [GB]),聚合它,并产生一个输出.
这是非常重要的是整个过程gathering the 4[GB] data的所有100 servers花费尽可能少的时间尽可能.我该如何解决这个问题?
是否有任何python可以提供帮助的现有工具(理想情况下,但会考虑其他解决方案)?
本学期我已经学习了数据库类,我们正在研究如何在RDBMS和缓存服务器(如memcached)之间保持缓存一致性.存在竞争条件时会出现一致性问题.例如:
get(key)从缓存中执行了操作,并且存在缓存未命中.因为我得到了缓存未命中,我从数据库中获取数据,然后put(key,value)进入缓存.put进入缓存之前发生.因此,理想情况下put不应该进入缓存,因为数据在数据库中存在的时间更长.
如果缓存条目具有TTL,则缓存中的条目可能会过期.但是,仍有一个窗口,其中缓存中的数据与数据库不一致.
我一直在寻找那些谈论这类问题的文章/研究论文.但是,我找不到任何有用的资源.
memcached caching consistency distributed-computing race-condition
我有一个网络驱动器(Z:\),由多台Windows计算机共享.是否可以通过简单地在此网络驱动器上创建/删除文件来实现跨机器锁定?
例如,两台计算机A和B希望同时写入ID为123的共享资源.
其中一台计算机,比如A,首先通过创建一个空文件Z:\ locks\123来锁定资源.当B看到存在名为"123"的锁定文件时,B知道其他人正在使用资源123,所以它必须等待Z才能删除Z:\ locks\123才能访问资源.
这就像多线程中的关键部分,但我想在多台机器上完成它.
我正在尝试用Python实现.这是我想出的:
import os
import time
def lock_it(lock_id):
lock_path = "Z:\\locks\\" + lock_id
while os.path.exists(lock_path):
time.sleep(5) # wait for 5 seconds
# create the lock file
lock_file = open(lock_path, "w")
lock_file.close()
def unlock_it(lock_id):
# delete the lock file
lock_path = "Z:\\locks\\" + lock_id
if os.path.exists(lock_path):
os.remove(lock_path)
Run Code Online (Sandbox Code Playgroud)
这不起作用,因为可能有多个进程退出等待状态并同时创建锁定文件.
同样,问题是:是否可以在共享存储上实现跨机器锁定机制?
python synchronization locking distributed-computing multiprocessing
我想知道collectAsMap在Spark中是如何工作的.更具体地说,我想知道所有分区的数据聚合将在何处发生?聚合发生在主人或工人中.在第一种情况下,每个工作人员在master上发送数据,当master从每个worker收集数据时,master将汇总结果.在第二种情况下,工人负责汇总结果(在他们之间交换数据之后),之后结果将被发送给主人.
我必须找到一种方法,以便主人能够分别从每个分区收集数据,而无需工人交换数据.
我有关于序列化和导入的问题.
mod.py需要一个畅达/ PIP封装?mod.py被写入共享文件系统.In [1]: from distributed import Executor
In [2]: e = Executor('127.0.0.1:8786')
In [3]: e
Out[3]: <Executor: scheduler="127.0.0.1:8786" processes=2 cores=2>
In [4]: import socket
In [5]: e.run(socket.gethostname)
Out[5]: {'172.20.12.7:53405': 'n1015', '172.20.12.8:53779': 'n1016'}
In [6]: %%file mod.py
...: def hostname():
...: return 'the hostname'
...:
Overwriting mod.py
In [7]: import mod
In [8]: mod.hostname()
Out[8]: 'the hostname'
In [9]: e.run(mod.hostname)
distributed.utils - ERROR - No module named 'mod'
Run Code Online (Sandbox Code Playgroud) 我正在研究一个经常查询大量演员的应用程序,因此发送/接收大量消息.当应用程序在单个机器上运行时,这不是问题,因为消息是在单个JVM的边界内发送的,这是非常快的.但是,当我在多个节点上运行应用程序(使用akka-cluster)时,每个节点都承载这些actor的一部分,并且消息通过网络传播,这变得非常慢.
我想出的一个解决方案是在运行应用程序的每个节点上都有一个ManagerActor.这将极大地减少交换的消息数量(即,不是向每个参与者发送数千条消息,如果我们在3个节点上运行应用程序,我们发送3条消息 - 每个ManagerActor一个,然后在当前JVM中将消息发送到其他(成千上万)演员非常快.但是,我对Akka很新,我不太确定这样的解决方案是否合理.你觉得它有什么缺点吗?对Akka更好/更原生的任何其他选择?