标签: distributed-computing

我最近开始学习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 …

根据这篇文章,app-engine前端和游乐场后端通过RPC调用进行通信.可以创建app-engine前端实例和playground实例中的每一个以支持缩放.

我问自己,在保持RPC的同时,在前端请求和后端实例之间进行负载均衡的模式(解决方案)是什么？

一种解决方案可能是使用一个全局工作队列,其中任务通过"Reply-To"标头放入其中.此标头应指向放置响应的每个前端实例队列.类似于以下架构(来自RabbitMQ教程),后端实例之间共享rpc_queue:

我不确定这是一个很好的方法,尤其是如果共享队列处于脱机状态,整个系统都会失败(但是如何解决这个问题？).

谢谢.

在处理矩阵的并行分解时,我熟悉块分布,我们有(比方说)4个进程,每个进程都有自己的矩阵子区域:

因此,例如,我们在行(procrows)中的进程数等于2,列(proccols)中的进程数也等于2,如果原始矩阵大小为,则子矩阵A_local将具有大小.N/2 x M/2N x M

我正在阅读这个使用"块循环"分布的例子,在这部分中:

/* Begin Cblas context */
/* We assume that we have 4 processes and place them in a 2-by-2 grid */
int ctxt, myid, myrow, mycol, numproc;
int procrows = 2, proccols = 2;
Cblacs_pinfo(&myid, &numproc);
Cblacs_get(0, 0, &ctxt);
Cblacs_gridinit(&ctxt, "Row-major", procrows, proccols);

他们procrows和proccols是硬编码的,很好,但对于读过一个矩阵,有一个标题:

Nb和Mb将是[矩阵]块的行数和列数

我不明白这一点; 不Nb与Mb完全由N,M,procrows和proccols确定？

编辑

从运行示例中我可以看到进程0上的子矩阵具有矩阵左上角的所有元素,就像我上面的图片一样,这与Jonathan的答案相矛盾.但是,它适用于ScaLAPACK的Cholesky.

我有以下格式的 JSON 数据：

{
     "date": 100
     "userId": 1
     "data": [
         {
             "timeStamp": 101,
             "reading": 1
         },
         {
             "timeStamp": 102,
             "reading": 2
         }
     ]
 }
 {
     "date": 200
     "userId": 1
     "data": [
         {
             "timeStamp": 201,
             "reading": 3
         },
         {
             "timeStamp": 202,
             "reading": 4
         }
     ]
 }

我将其读入 Spark SQL：

val df = SQLContext.read.json(...)
df.printSchema
// root
//  |-- date: double (nullable = true)
//  |-- userId: long (nullable = true)
//  |-- data: array (nullable = true)
//  |     |-- element: …

我正在寻找分布式计时器服务。多个远程客户端服务应该能够在指定的时间间隔后注册回调（通过 REST api）。间隔的长度可以是 1 分钟。我可以忍受大约 1 分钟的误差。此类回调的数量目前可以达到 100,000，但我以后需要扩大规模。我一直在寻找类似的调度程序，Quartz但我不确定它们是否适合这个问题。使用Quartz，我可能不得不将回调请求保存在数据库中，并每分钟轮询 100,000 行的过期请求。我不确定这会扩大规模。是否有任何开箱即用的解决方案？否则，我该如何建造一个？

我在网上找到了两个定义：

顺序一致性——任何执行的结果都是一样的，就好像所有处理器的操作都是按某种顺序执行的，每个处理器的操作都按照其程序指定的顺序出现在这个序列中。

最终一致性——如果没有对给定数据项进行新的更新，最终对该项目的所有访问都将返回最后更新的值。

这些定义对我来说很清楚。但是，当最终一致性不是连续的时，我不明白。一个例子：mem 中的初始值是 0。横轴是时间。

P1:      write 1             (x)
P2:  read 0    read 0 read 0     read 1   read 1    read 1

因此，有一些顺序顺序，如果我们在 (x) 槽中放置“写入 1”，这就是顺序一致性的定义。我哪里错了？

我分别找到了分布式系统和分布式计算的以下定义:

分布式系统:与互连网络连接的独立计算机的集合.

分布式计算:一种计算机处理方法,其中计算机程序的不同部分在通过网络相互通信的两台或多台计算机上运行.

但是,我不清楚两者之间的差异是什么.分布式系统和分布式计算有什么区别？

我一直无法找到适合Vector Clocks和Version Vectors 的用例以及它们可能有何不同的示例。我知道它们在很大程度上以相同的方式工作，向量时钟使用receive和send函数，版本向量使用sync函数，但我不明白这两个选项之间的区别。它只是表达同一事物的两种不同方式，还是它们之间的用例存在真正的差异？

我只能找到一个有点相关的问题：“我什么时候使用像 Paxos 这样的共识算法与使用像 Vector Clock 这样的算法？”

尽管链接的答案陈述了以下内容并引用了一篇短文，但我仍然不清楚这些差异。

您可能希望将版本向量用于无领导分布式存储。您可能会为此使用矢量时钟（尽管它更适合；本文还建议您将其用于一致的快照，用于在一般分布式系统中实现因果排序等）。

在云计算的上下文中，后端开发人员经常提到构建（或使用）“服务网格”，但我并不完全理解它是什么。你能说更多吗？

假设我有一个 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问了一个类似的问题，但到目前为止还没有答案。