标签: distributed-computing

在 Ray Core 的文档中找到了这个缩写词，用于其主要 API 服务器：

[..] the head node needs to open several more ports:
    --port: Port of Ray (GCS server). The head node will start a GCS server listening on this port. Default: 6379.

这些模块旨在促进跨多台计算机的计算能力层.有哪些一种或多种经过验证的方法可以防止欺骗性数据包？如何最好地对传输的可调用引用的任何未包含的对象进行深层复制？函数对象是封装客户端作业的最佳方法吗？最后:这段代码可以改进吗？邮件脚本:请原谅我的最后一个问题.我需要兑现我的声誉.

sock.py

from socket import socket
from socket import AF_INET
from socket import SOCK_STREAM
from socket import gethostbyname
from socket import gethostname

class SocketServer:
  def __init__(self, port):
    self.sock = socket(AF_INET, SOCK_STREAM)
    self.port = port
  def send(self, tdata):
    self.sock.bind(("127.0.0.1", self.port))
    self.sock.listen(len(tdata))
    while tdata:
      s = self.sock.accept()[0]
      for x in tdata.pop(): s.send(x)
      s.close()
    self.sock.close()

class Socket:
  def __init__(self, host, port):
    self.sock = socket(AF_INET, SOCK_STREAM)
    self.sock.connect((host, port))
  def recv(self, size):
    return self.sock.recv(size)
  def close(self):
    self.sock.close()

pack.py

#http://stackoverflow.com/questions/6234586/we-need-to-pickle-any-sort-of-callable
from marshal import dumps as marshal_dumps …

我有一个特定的DLL,其中包含一些语言处理类和方法.其中一个方法获取一个单词作为参数,并进行一些约3秒的计算,并将相关结果保存在SQL-Server Db上.

我想在900k字上运行这个DLL方法,这个工作可能每周重复一次.如何在多个系统上轻松分发此工作以节省使用c#的时间？

我有一个基于Azure的Web服务.该服务包含一个基于Web的前端,通过JSON和Ajax与运行在同一Web角色中的WCF服务进行通信.这又与另一个WCF服务进行通信,该服务在单独的Web角色中充当我们的中间层.这与包含两个SQL Azure数据库和一些blob存储的后端进行通信.部署后,所有这些都被放置在西欧地区(我在英国).部分Web服务涉及上传多张可能较大的照片.如果我们在美国的用户使用美国托管的前端和中间层上传到美国的数据存储和数据库,那将是有意义的.Azure是否提供了一种解决方案,我可以跨大洲复制我的基础架构并让Azure处理所需的重定向？如果是这样,我该如何设置？

在Hadoop MapReduce中,对于中间输出(由map()生成),我希望中间输出的值是以下对象.

MyObject{
  date:Date
  balance:Double
}

我该怎么做 我应该创建自己的可写类吗？

我是MapReduce的新手.

谢谢.

我已经使用HDFS设置了Spark集群配置,我知道在HDFS示例中Spark将会读取所有默认文件路径:

/ad-cpc/2014-11-28/ Spark will read in : hdfs://hmaster155:9000/ad-cpc/2014-11-28/

有时我想知道如何强制Spark在本地读取文件而不重新配置我的集群(不使用hdfs).

请帮我 !!!

我读到当前的主要选举算法如Raft,Paxos或Zab如何选择群集上的主人,并且无法理解为什么他们使用复杂的算法而不是简单的欺负算法.

我正在开发一个集群库,并使用UDP Multicast来处理心跳消息.每个节点都加入一个多播地址,并定期向该地址发送数据报包.如果节点发现有一个新节点将数据包发送到此多播地址,则该节点只是添加到集群中,类似地,当集群中的节点没有从节点获取任何程序包时,它们会将其从集群中删除.当我需要选择一个主节点时,我只需遍历集群中的节点并选择最旧的节点.

我阅读了一些文章,暗示这种方法无效,应该使用像Paxos这样的更复杂的算法,以便通过心跳消息选出主控或检测故障.我无法理解为什么Paxos比传统的欺负算法更适合裂脑情况或其他网络故障,因为我可以很容易地发现当法定数量的节点离开集群而不使用Raft时.我看到的唯一好处是每个服务器必须处理的数据包数量; 只有master在Raft中发送心跳消息,而在这种情况下,每个节点都必须向对方发送心跳消息.但是我不认为这是一个问题,因为我可以简单地实现类似的心跳算法而不改变我的主选举算法.

有人可以详细说明吗？

根据Spark文档，

Spark中的所有转换都是惰性的，因为它们不会立即计算出结果。相反，他们只记得应用于某些基本数据集（例如文件）的转换。仅当动作要求将结果返回给驱动程序时才计算转换。

我目前正在处理一个大型数据集，一旦处理该数据集，它会输出甚至更大数量的数据，这些数据需要存储在文本文件中，就像使用command一样saveAsTextFile(path)。

到目前为止，我一直在使用这种方法。但是，由于这是一个操作（如上所述），而不是转换，因此Spark需要将数据从每个分区发送到驱动程序节点，从而大大降低了保存过程。

我想知道saveAsTextFile()Spark上是否存在任何分布式文件保存方法（类似于），从而使每个执行程序能够自己存储自己的分区。

我正在尝试在pyspark中开发一个算法,我正在使用linalg.SparseVector类.我需要创建一个键值对的字典作为每个SparseVector对象的输入.这里的键必须是整数,因为它们表示整数(在我的例子中代表用户ID).我有一个单独的方法读取输入文件并返回一个字典,其中每个用户ID(字符串)映射到一个整数索引.当我再次浏览文件并执行操作时

FileRdd.map(lambda x:userid_idx [x [0]]).我收到一个KeyError.我想这是因为我的dict对所有分区都不可用.有没有办法让所有分区都可以使用userid_idx dict,类似于MapReduce中的分布式地图？我也为这个烂摊子道歉.我是用手机发布的.将在我的笔记本电脑上更新一段时间.

承诺的代码:

from pyspark.mllib.linalg import SparseVector
from pyspark import SparkContext
import glob
import sys
import time
"""We create user and item indices starting from 0 to #users and 0 to #items respectively. This is done to store them in sparseVectors as dicts."""
def create_indices(inputdir):
    items=dict()
    user_id_to_idx=dict()
    user_idx_to_id=dict()
    item_idx_to_id=dict()
    item_id_to_idx=dict()
    item_idx=0
    user_idx=0
    for inputfile in glob.glob(inputdir+"/*.txt"):
        print inputfile
        with open(inputfile) as f:
            for line in f:
                toks=line.strip().split("\t")
                try:
                    user_id_to_idx[toks[1].strip()]
                except KeyError:
                    user_id_to_idx[toks[1].strip()]=user_idx
                    user_idx_to_id[user_idx]=toks[1].strip()
                    user_idx+=1
                try:
                    item_id_to_idx[toks[0].strip()] …

我有一个大型数据集,我试图用Apache Spark运行(大约5TB).我注意到,当作业开始时,它会非常快速地检索数据,并且作业的第一阶段(map转换)非常快速地完成.

但是,在处理了大约500GB的数据之后,这种map转换开始变慢,一些任务需要几分钟甚至几小时才能完成.

我正在使用10台机器,122 GB和16CPU,我正在为每个工作节点分配所有资源.我想过增加机器的数量,但还有其他的东西我可能会丢失吗？

我尝试了一小部分数据集(30 GB),似乎工作正常.