标签: distributed-computing

我想在我的代码中逐步构建一组Celery 任务，因为我将在循环中根据逻辑创建任务。

例如：

my_group = group()
for item in items:
    if item.is_special():
        # This doesn't work...
        my_group.add(special_processing.s(item.id))
    else:
        my_group.add(regular_processing.s(item.id))

 res = my_group()

我读过组是部分，这很好，但是您如何组合部分以便它们形成一个组？

我从Google 文件系统论文中不明白这一点

一个小文件由少量块组成，也许只有一个。如果许多客户端访问同一个文件，存储这些块的块服务器可能会成为热点。

小文件有什么区别？许多客户端访问的大文件是否同样有可能导致问题？

我想过/阅读以下内容：-

• 我假设（如果我错了，请纠正我）大文件块存储在不同的块服务器上，从而分配负载。在这种情况下，假设 1000 个客户端从每个块服务器访问文件的 1/100。所以每个 chunkserver 最终都会不可避免地收到 1000 个请求。（这与 1000 个客户端访问单个小文件不同。服务器收到 1000 个小文件请求或 1000 个大文件部分请求）
• 我读了一些关于稀疏文件的内容。小文件根据文件填满一个块或几个块。因此，据我所知，不会重建小文件，因此我已将其排除为热点的可能原因。

我正在对 ZFS 进行一些研究，如果它可以用作分布式处理框架的组件。我要回答的主要问题是 - 如果数据驻留在 zfs 中，Apache Spark 是否会以高效的分布式方式运行？

IE。HDFS 上的 Spark 有数据局部性的概念，ZFS 也可以这样说。

我使用的是在独立模式下配置的 Spark 2.2.0 集群。Cluster有2个八核机器。该集群专用于 Spark 作业，没有其他进程使用它们。我有大约 8 个 Spark Streaming 应用程序在这个集群上运行。
我将 SPARK_WORKER_CORES（在 spark-env.sh 中）明确设置为 8，并使用 total-executor-cores 设置为每个应用程序分配一个内核。此配置降低了在多个任务上并行工作的能力。如果一个 stage 在一个有 200 个分区的分区 RDD 上工作，则一次只执行一个任务。我想让 Spark 做的是为每个作业启动单独的线程并并行处理。但是我找不到单独的 Spark 设置来控制线程数。
因此，我决定尝试将每台机器上的内核数量（即 spark-env.sh 中的 SPARK_WORKER_CORES）增加到 1000。然后我为每个 Spark 应用程序提供了 100 个内核。我发现 spark 这次开始并行处理 100 个分区，表明正在使用 100 个线程。
我不确定这是否是影响 Spark 作业使用的线程数的正确方法。

在跨多个服务器和 GPU 训练神经网络时，我想不出ParameterServerStrategy比MultiWorkerMirroredStrategy.

ParameterServerStrategy的主要用例是什么，为什么它比 using 更好MultiWorkerMirroredStrategy？

大家好，我最近几天使用 Nodejs 开发了一个简单的应用程序，并创建了这个函数来从 mongodb 返回客户端实例

const mongodb = require("mongodb");
const { db } = require("../config/env");

const conection = async () => {
    try {
        const client = await mongodb.MongoClient.connect(db.uri, {
            useNewUrlParser: true,
            useUnifiedTopology: true,
        });
        return client;
    } catch (error) {
        throw error;
    }
};

module.exports = conection;

我为访问数据层创建了这个简单的函数并返回插入的记录

const index = async ({ limit = 10, offset = 0, filter = {} }) => {
    const client = await conection();
    if (filter._id) {
        filter._id = mongodb.ObjectID(filter._id);
    }
    try { …

从大 csv 文件读取数据时，spark 中的数据初始partitions发生在什么基础上？

从大 csv 文件读取时，它将如何决定将大文件数据的分区数量/拆分到不同的工作节点中？

谁能分享一下，它是如何完成的？

在分布式计算设置中,我想向许多节点发送unordered_set.我知道C++中的序列化,例如使用boost::serialization.我对序列化的看法是,unordered_set在接收到序列化数据后,我面临着在每个节点上重建数据结构的成本.

我的想法是为unordered_set编写一个自定义分配器,它分配一个固定大小的连续内存,并在分配后返回起始内存地址.然后我想获取它的字节表示,unordered_set通过线路发送它,并告诉接收节点这个内存块是一个unordered_set.

那会有用吗？你们有没有其他想法如何解决我的问题？或者你有任何相关的指针,例如写这样的分配器？任何反馈都表示赞赏.

谢谢!

在CAP定理中,"P"(分区)组件基本上表明尽管有物理网络分区,系统仍能正常工作.

我认为"C"(一致性)和"A"(可用性)在DDBMS环境中对我来说非常有意义:一致性,所有客户端必须具有一致的数据视图,而不管它们所服务的数据库节点如何.并且在可用性的情况下,所有客户端必须能够从某个 DB节点获取读/写的响应(即,所有节点永远不会同时关闭).

但由于某种原因,我对CAP的分区问题感到窒息,其重要性在于它,特别是对于DDBMS.

对于分布式数据库,根据定义,您可以拥有多个(群集)节点.根据网络和系统架构,物理设备等,无论如何,在节点之间复制或通信(半连接等)时,您将遇到性能问题.CAP中的"P"只是加速DDBMS性能的一种方式; 没有P保证会否则会受到阻碍的表现？

另外,"P"如何与单个节点(非群集)DB相关？在这种情况下,我觉得这完全无关紧要.提前致谢!

我试图使用MPI找到长度为100的元素数组的总和,在仅使用MPI_Send和MPI_receive的限制下,我写的代码找到了每个处理器的总和但在重新发送到主处理器期间( rank = 0)我的代码只从一个处理器接收

我的守则

#include "stdafx.h"
#include <stdio.h>
#include <string.h>
#include "mpi.h"
#include "math.h"

int val = 1;
int main(int argc, char* argv[]) {

    int my_rank;
    int p;
    int ierr;
    int i;
    int a[100];
    int q=0;
    for (i = 0; i <100; i++)
    {
        a[i] = i+1;
    }
    int send,recv;
    MPI_Status status;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
    MPI_Comm_size(MPI_COMM_WORLD, &p);
    int part = 100 /(p-1);
    if (my_rank == 0)
    {
        for (i = 1; i < p; i++)
        {
            send = …