标签: distributed-computing

相关问题: 打破集中式数据库的最有效方法是什么？

我将尝试使这个问题相当普遍,这将有利于其他人.

大约3年前,我实施了一个集成的CRM和网站.因为我想给客户留下深刻的印象,所以我实现了我能想到的最便宜的架构,即在Web服务器上托管中央数据库和网站.我创建了一个桌面应用程序,它通过Web服务与Web服务器通信(该应用程序从其主办公室运行).

事后看来,这是相当愚蠢的,因为现在公司已经发展壮大,他们的互联网连接每个月变得越来越慢.现在,由于速度问题,桌面软件定期超时,客户有3个选项:

1. 购买更快的互联网连接.
2. 将数据库(和网站)移动到内部服务器.
3. 重新设计架构,以便CRM和Web数据库是分开的.

第一种选择是"最简单",但肯定不是最便宜的长期选择.第二种选择; 如果我们将网站转移到内部托管,客户必须解决超载/差/离线互联网连接,断电等问题.最后的选择; 客户厌倦了为我重新设计和重新编码架构而付出了大量现金,我无法承担免费的费用(我需要吃饭).

有没有办法从你搞砸了分布式系统的设计那么糟糕的时候恢复,没有一个选项可以工作？或者是减少损失并从错误中吸取教训的情况？我觉得很难解决这个问题.

我创建了一个绝对没有任何内容的网站,我已经向自己证明了人们喜欢呆在那里 - 我已经在页面上记录了超过11个小时的累积时间.

我的问题是,将网站用作分布式计算网站是否可能(或实际).

我的第一个冲动是找出是否有任何JavaScript分布式计算项目已经处于活动状态,以便我可以在页面上放置一段代码并完成.不幸的是,我所能找到的只是一大堆网站,认为这可能是一个很酷的主意.

我想我可能想要从整数分解开始 - 在这种情况下,RSA数字.服务器很容易检查答案是否正确(只需测试模数等于零),并且易于实现.

我的想法可行吗？那里有一个我可以使用的项目吗？

跟进我之前的问题:

在PostgreSQL中使用"Cursors"进行分页

为API客户端提供1,000,000个数据库结果的好方法是什么？

我们目前正在使用PostgreSQL.一些建议的方法:

• 使用游标进行分页
• 使用随机数进行分页(为每个查询添加"GREATER THAN BYDER BY")
• 使用LIMIT和OFFSET进行分页(针对非常大的数据集进行分解)
• 将信息保存到文件中,然后让客户端下载它
• 迭代结果,然后将数据POST到客户端服务器
• 仅返回客户端的密钥,然后让客户端从Amazon S3等云文件中请求对象(仍然可能需要分页才能获取文件名).

我没有想到的是愚蠢的简单和比任何这些选项更好的方式？

我见过的Akka演员的大部分用例都是高性能的多核服务器或本地集群.

我很好奇它适用于更远程的高延迟和高度失败的群体结构,如p2p网络.

我想到的应用程序将有关于群集节点的可信性和/或资源丰富性的规则,给予它们一些状态,就像bittorrent一样.它还需要能够尽可能地在整个群体中传播交易,但最终或部分一致性是可以接受的.可伸缩性比一致性更重要.

AKKA是建立这样的东西的潜在解决方案吗？它会比其他方法有任何特定的优点或缺点.

因此,对于拥有大量数据集的大型网络,它们需要一段时间才能进行训练.如果有一种方法可以跨多台机器共享计算时间,那将是非常棒的.然而,问题在于,当神经网络进行训练时,权重会在每次迭代时不断变化,每次迭代或多或少都基于最后一次 - 这使得分布式计算的想法至少成为挑战.

我认为,对于网络的每个部分,服务器可能会发送1000组数据来训练网络......但是......你的计算时间大致与我无法计算的时间相同同时训练不同的数据集(这是我想做的).

但即使我可以将网络训练分成不同数据集的块进行训练,我怎么知道我何时完成了这组数据？特别是如果发送到客户端计算机的数据量不足以实现所需的错误？

我欢迎所有想法.

阅读Google的Dataflow API,我的印象是它与Apache Storm的功能非常相似.通过流水线流实时数据处理.除非我完全忽略了这一点,否则我不希望在如何执行彼此写入的管道上建立桥梁,而是期待与Google不同的东西,而不是重新发明轮子.Apache Storm已经很好地放置并可用于任何编程语言.做这样的事情的真正价值是什么？

我在Apache Spark代码源中遇到了这一行

val (gradientSum, lossSum, miniBatchSize) = data
    .sample(false, miniBatchFraction, 42 + i)
    .treeAggregate((BDV.zeros[Double](n), 0.0, 0L))(
      seqOp = (c, v) => {
        // c: (grad, loss, count), v: (label, features)
        val l = gradient.compute(v._2, v._1, bcWeights.value, Vectors.fromBreeze(c._1))
        (c._1, c._2 + l, c._3 + 1)
      },
      combOp = (c1, c2) => {
        // c: (grad, loss, count)
        (c1._1 += c2._1, c1._2 + c2._2, c1._3 + c2._3)
      }
    )

我读这个有多个麻烦:

• 首先,我在网上找不到任何可以解释确切treeAggregate工作方式的内容,这些内容的含义是什么.
• 其次,这里.treeAggregate的方法名称似乎有两个()().这意味着什么？这是一些我不理解的特殊scala语法.
• 最后,我看到seqOp和comboOp都返回一个3元素元组,它与预期的左侧变量匹配,但实际返回了哪一个？

这个陈述必须非常先进.我无法开始破译这一点.

对于我的代码段如下:

val levelsFile = sc.textFile(levelsFilePath)
val levelsSplitedFile = levelsFile.map(line => line.split(fileDelimiter, -1))
val levelPairRddtemp = levelsSplitedFile
                              .filter(linearr => ( linearr(pogIndex).length!=0))
                              .map(linearr => (linearr(pogIndex).toLong, levelsIndexes.map(x => linearr(x))
                              .filter(value => (!value.equalsIgnoreCase("") && !value.equalsIgnoreCase(" ") && !value.equalsIgnoreCase("null")))))
                              .mapValues(value => value.mkString(","))
                              .partitionBy(new HashPartitioner(24))
                              .persist(StorageLevel.MEMORY_ONLY_SER)

levelPairRddtemp.count // just to trigger rdd creation

信息

1. 文件的大小是~4G
2. 我使用2 executors(每个5G)和12个核心.
3. Spark 版本:1.5.2

问题

当我看到它SparkUI时Storage tab,我看到的是:

在里面RDD看来,24个partitions中只有2个被缓存.

对此行为的任何解释,以及如何解决此问题.

编辑1:我刚尝试使用60个分区HashPartitioner作为:

..
.partitionBy(new HashPartitioner(60))
..

它工作了.现在我得到了整个RDD缓存.有什么猜测这里可能发生了什么？数据偏差是否会导致此行为？ …

我的理解是，部分排序和全排序是两组规则。

偏序具有三个规则：
(1) 如果 a 和 b 是同一进程中的两个事件，并且 a 在 b 之前，则 a->b。
(2) ...
(3) ...

那么什么是全序呢？

为何如此命名？

我一直在阅读一些文档和示例代码，最终目标是为分布式计算（运行 PyTorch）编写脚本，但这些概念让我感到困惑。

假设我们有一个带有 4 个 GPU 的节点，并且我们希望在这 4 个 GPU 上运行我们的脚本（即每个 GPU 一个进程）。在这种情况下，排名世界大小和排名是多少？我经常找到对世界大小的解释：工作中涉及的进程总数，所以我假设在我们的例子中是四个，但是排名呢？

为了进一步解释，另一个具有多个节点和多个 GPU 的示例也很有用。