标签: distributed-computing

我想知道在分布式系统中追踪性能瓶颈的可能方法。我知道X-Trace等工具及其后代（例如Dapper），但我对方法论而不是特定工具更感兴趣。

换句话说，给定一个没有任何明显瓶颈的分布式系统，你如何研究和提高它的性能？

我正在构建一个 erlang 环境，该环境管理分布在运行 Linux 的网络上的单个应用程序。

关于构建前端的最佳方式的任何想法，例如在 VB.Net 或 CSharpe 中为此服务器。我想主要的想法是 Erlang 是否可以与 GUI 前端相结合。

有没有人有为 Erlang 构建高度交互的前端的经验？

Mirroring在Kafka集群之间复制数据，而在Kafka集群Replication内复制节点。

Replication如果Mirroring已经设置，是否有任何特定用途？

每次我遇到诸如“进程 0 执行x任务”之类的内容时，我都倾向于认为它们是指处理器。

After reading a bit more about it, I find that there are two memory classifications, shared memory and distributed memory: A shared memory executes something like a thread (implying same data is available to all processors- hence it makes sense to call it a process) However, even for distributed memory it is called a process instead of a processor. For example: "Process 0 is computing the partial dot product" …

我想为我的 Spark 程序执行速度计时，但由于懒惰，这非常困难。让我们在这里考虑一下这个（无意义的）代码：

var graph = GraphLoader.edgeListFile(context, args(0))
val graph_degs = graph.outerJoinVertices(graph.degrees).triplets.cache

/* I'd need to start the timer here */
val t1 = System.currentTimeMillis  
val edges = graph_degs.flatMap(trip =>  { /* do something*/ })
                      .union(graph_degs)

val count = edges.count
val t2 = System.currentTimeMillis 
/* I'd need to stop the timer here */

println("It took " + t2-t1 + " to count " + count)

问题是，转换是懒惰的，所以val count = edges.count在行之前没有任何评估。但是根据我的观点，t1尽管上面的代码没有值，但还是得到了一个值……t1尽管在代码中的位置，但在计时器启动后对上面的代码进行了评估。那是个问题...

在 Spark Web UI 中，我找不到任何有趣的东西，因为我需要在该特定代码行之后花费时间。您认为是否有一个简单的解决方案可以查看何时对一组转换进行真实评估？

我似乎在 Druid 网站上找不到任何特定的教程/文档页面，其中列出了 Druid 中所有支持的维度数据类型。从我阅读的内容来看，我知道这一点long, float并且string绝对受支持，但我对其他受支持类型的信息几乎为零。

对此的任何帮助将不胜感激，谢谢！

分布式系统建议使用奇数个 Master 节点，例如 3 个 Master 节点或 5 个 Master 节点，以避免脑裂问题。

但是它是如何解决问题的呢？

如果有2个节点（A和B），1个主持人，如果A和B告诉主持人“我是大师”，那么就会发生脑裂。主持人无法决定谁是大师。

如果有 3 个节点（A、B 和 C），那么如果有 2 个节点说 Master 是 A，那么 Moderator 可以决定 A 是 Master。

但是如果A死了，那么Moderator必须从B和C中选择一个Master，如果B和C告诉Moderator“我是Master”呢？脑裂再次出现。

我有一个 python 服务器和一个 node.js 客户端。问题是，有时当我重新启动 node.js 脚本时，它不会重新连接。

另外，我不明白的是为什么python上有一个无限循环。我不能使用事件来侦听连接。

下面是服务器和客户端。

context = zmq.Context()
socket = context.socket(zmq.PAIR)
print("Binding socket to port: " + str(port))
socket.bind("tcp://*:%s" % port)
print("Connection has been established")
while True: // cant we listen for events here i.e on connection etc
    msg = socket.recv()
    print(msg)
    socket.send("Server response")

'use strict';
var globevt  = require('../lib/emitter');
var sprintf  = require("sprintf-js").sprintf;
var logger   = require('../lib/logat');
var zmq      = require('zeromq')
    , socket = zmq.socket('pair');
const fs     = require('fs');

socket.connect('tcp://127.0.0.1:3000');
socket.on('message', function (msg) {
    console.log(msg); …

我在 ZMQ 中的几个程序实例之间的进程间通信遇到了一些问题

• 我正在使用 Linux 操作系统
• 我正在使用 zeromq/cppzmq，libzmq 的仅标头 C++ 绑定

如果我运行此应用程序的两个实例（比如在终端上），我会为一个实例提供一个作为侦听器的参数，然后为另一个提供一个作为发送方的参数。侦听器永远不会收到消息。我试过 TCP 和 IPC 都无济于事。

#include <zmq.hpp>
#include <string>
#include <iostream>

int ListenMessage();
int SendMessage(std::string str);

zmq::context_t global_zmq_context(1);

int main(int argc, char* argv[] ) {
    std::string str = "Hello World";
    if (atoi(argv[1]) == 0) ListenMessage();
    else SendMessage(str);

    zmq_ctx_destroy(& global_zmq_context);
    return 0;
}


int SendMessage(std::string str) {
    assert(global_zmq_context);
    std::cout << "Sending \n";
    zmq::socket_t publisher(global_zmq_context, ZMQ_PUB);
    assert(publisher);

    int linger = 0;
    int rc = zmq_setsockopt(publisher, ZMQ_LINGER, &linger, sizeof(linger));
    assert(rc==0);

    rc = …

什么可能是实现幂等性并处理竞争条件的替代解决方案。

例如。考虑将客户添加到记录系统的请求。客户详细信息将以电子邮件 ID 作为关键属性。并假设有 API 来创建客户。

考虑一种情况，由于来自客户端的重复请求，在时间 T1，两个请求可能会登陆服务器以创建相同电子邮件 ID 的客户，例如“xyz@abc.com”。

请求 1，时间 T1，电子邮件 ID“xyz@abc.com” 请求 2，时间 T1，电子邮件 ID“xyz@abc.com”

我正在寻找分布式系统如何在 REST API 调用中处理幂等性和竞争条件的方法？我知道有不同的方法，例如，

• 数据库约束
• 分布式锁

DB Constraint on column email id，很容易解决这个问题。也可以选择分布式锁或使用 no-sql 方法在将记录存储之前检查缓存中的电子邮件 ID。

考虑到分布式特性，还有哪些其他可扩展的方法？

为什么要避免约束是，它对索引、性能和规模都有影响。