- c - 在位数组中找到第一个零
- linux - Unix 显示有关匹配两种模式之一的文件的信息
- 正则表达式替换多个文件
- linux - 隐藏来自 xtrace 的命令
我正在使用大小约为 100 MB 的广播变量,我将其近似为:
>>> data = list(range(int(10*1e6)))
>>> import cPickle as pickle
>>> len(pickle.dumps(data))
98888896
在具有 3 个 c3.2xlarge 执行程序和一个 m3.large 驱动程序的集群上运行,使用以下命令启动交互式 session :
IPYTHON=1 pyspark --executor-memory 10G --driver-memory 5G --conf spark.driver.maxResultSize=5g
在 RDD 中,如果我持久化对这个广播变量的引用,内存使用量就会激增。对于 100 MB 变量的 100 次引用,即使它被复制 100 次,我预计数据使用总量也不会超过 10 GB(更不用说 3 个节点上的 30 GB 了)。但是,当我运行以下测试时,我看到内存不足的错误:
data = list(range(int(10*1e6)))
metadata = sc.broadcast(data)
ids = sc.parallelize(zip(range(100), range(100)))
joined_rdd = ids.mapValues(lambda _: metadata.value)
joined_rdd.persist()
print('count: {}'.format(joined_rdd.count()))
堆栈跟踪:
TaskSetManager: Lost task 17.3 in stage 0.0 (TID 75, 10.22.10.13):
org.apache.spark.api.python.PythonException: Traceback (most recent call last):
File "/usr/lib/spark/python/lib/pyspark.zip/pyspark/worker.py", line 111, in main
process()
File "/usr/lib/spark/python/lib/pyspark.zip/pyspark/worker.py", line 106, in process
serializer.dump_stream(func(split_index, iterator), outfile)
File "/usr/lib/spark/python/pyspark/rdd.py", line 2355, in pipeline_func
return func(split, prev_func(split, iterator))
File "/usr/lib/spark/python/pyspark/rdd.py", line 2355, in pipeline_func
return func(split, prev_func(split, iterator))
File "/usr/lib/spark/python/pyspark/rdd.py", line 317, in func
return f(iterator)
File "/usr/lib/spark/python/pyspark/rdd.py", line 1006, in <lambda>
return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
File "/usr/lib/spark/python/pyspark/rdd.py", line 1006, in <genexpr>
return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
File "/usr/lib/spark/python/lib/pyspark.zip/pyspark/serializers.py", line 139, in load_stream
yield self._read_with_length(stream)
File "/usr/lib/spark/python/lib/pyspark.zip/pyspark/serializers.py", line 164, in _read_with_length
return self.loads(obj)
File "/usr/lib/spark/python/lib/pyspark.zip/pyspark/serializers.py", line 422, in loads
return pickle.loads(obj)
MemoryError
at org.apache.spark.api.python.PythonRDD$$anon$1.read(PythonRDD.scala:138)
at org.apache.spark.api.python.PythonRDD$$anon$1.<init>(PythonRDD.scala:179)
at org.apache.spark.api.python.PythonRDD.compute(PythonRDD.scala:97)
at org.apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:297)
at org.apache.spark.rdd.RDD.iterator(RDD.scala:264)
at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:66)
at org.apache.spark.scheduler.Task.run(Task.scala:88)
at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:214)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at org.apache.spark.scheduler.Task.run(Task.scala:88)
at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:214)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.java:745)
16/05/25 23:57:15 ERROR TaskSetManager: Task 17 in stage 0.0 failed 4 times; aborting job
---------------------------------------------------------------------------
Py4JJavaError Traceback (most recent call last)
<ipython-input-1-7a262fdfa561> in <module>()
7 joined_rdd.persist()
8 print('persist called')
----> 9 print('count: {}'.format(joined_rdd.count()))
/usr/lib/spark/python/pyspark/rdd.py in count(self)
1004 3
1005 """
-> 1006 return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum()
1007
1008 def stats(self):
/usr/lib/spark/python/pyspark/rdd.py in sum(self)
995 6.0
996 """
--> 997 return self.mapPartitions(lambda x: [sum(x)]).fold(0, operator.add)
998
999 def count(self):
/usr/lib/spark/python/pyspark/rdd.py in fold(self, zeroValue, op)
869 # zeroValue provided to each partition is unique from the one provided
870 # to the final reduce call
--> 871 vals = self.mapPartitions(func).collect()
872 return reduce(op, vals, zeroValue)
873
/usr/lib/spark/python/pyspark/rdd.py in collect(self)
771 """
772 with SCCallSiteSync(self.context) as css:
--> 773 port = self.ctx._jvm.PythonRDD.collectAndServe(self._jrdd.rdd())
774 return list(_load_from_socket(port, self._jrdd_deserializer))
775
/usr/lib/spark/python/lib/py4j-0.8.2.1-src.zip/py4j/java_gateway.py in __call__(self, *args)
at py4j.reflection.MethodInvoker.invoke(MethodInvoker.java:231)
at py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.java:379)
at py4j.Gateway.invoke(Gateway.java:259)
at py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:133)
at py4j.commands.CallCommand.execute(CallCommand.java:79)
at py4j.GatewayConnection.run(GatewayConnection.java:207)
at java.lang.Thread.run(Thread.java:745)
我已经看到以前的线程关于 pickle 反序列化的内存使用是一个问题。但是,我希望广播变量仅被反序列化(并在执行程序上加载到内存中)一次,随后对 .value
的引用将引用该内存地址。然而,情况似乎并非如此。我错过了什么吗?
我看到的广播变量示例将它们作为字典,用于一次转换一组数据(即用机场名称替换机场首字母缩写词)。将它们保留在这里的动机是创建具有广播变量知识的对象以及如何与之交互、保留这些对象并使用它们执行多项计算(spark 负责将它们保存在内存中)。
使用大型(100 MB 以上)广播变量有哪些技巧?坚持广播变量是否被误导?这可能是 PySpark 特有的问题吗?
谢谢!感谢您的帮助。
请注意,我还在 databricks forums 上发布了这个问题
编辑 - 后续问题:
建议默认的 Spark 序列化器的批处理大小为 65337。在不同批处理中序列化的对象不会被识别为相同的,并且会分配不同的内存地址,通过内置的 id
函数检查.然而,即使使用理论上需要 256 批序列化的更大广播变量,我仍然只能看到 2 个不同的副本。我不应该看更多吗?我对批量序列化工作原理的理解有误吗?
>>> sc.serializer.bestSize
65536
>>> import cPickle as pickle
>>> broadcast_data = {k: v for (k, v) in enumerate(range(int(1e6)))}
>>> len(pickle.dumps(broadcast_data))
16777786
>>> len(pickle.dumps({k: v for (k, v) in enumerate(range(int(1e6)))})) / sc.serializer.bestSize
256
>>> bd = sc.broadcast(broadcast_data)
>>> rdd = sc.parallelize(range(100), 1).map(lambda _: bd.value)
>>> rdd.map(id).distinct().count()
1
>>> rdd.cache().count()
100
>>> rdd.map(id).distinct().count()
2
最佳答案
嗯,细节决定成败。要了解发生这种情况的原因,我们必须仔细研究 PySpark 序列化程序。首先让我们使用默认设置创建 SparkContext
:
from pyspark import SparkContext
sc = SparkContext("local", "foo")
并检查什么是默认序列化程序:
sc.serializer
## AutoBatchedSerializer(PickleSerializer())
sc.serializer.bestSize
## 65536
它告诉我们三个不同的事情:
AutoBatchedSerializer
序列化器PickleSerializer
来执行实际工作bestSize
为65536字节快速浏览 at the source code将向您展示此序列化在运行时调整当时序列化的记录数,并尝试使批处理大小小于 10 * bestSize
。重要的一点是,并非单个分区中的所有记录都同时序列化。
我们可以通过如下实验验证:
from operator import add
bd = sc.broadcast({})
rdd = sc.parallelize(range(10), 1).map(lambda _: bd.value)
rdd.map(id).distinct().count()
## 1
rdd.cache().count()
## 10
rdd.map(id).distinct().count()
## 2
正如您在序列化-反序列化之后的这个简单示例中所看到的,我们得到了两个不同的对象。您可以直接使用 pickle
观察到类似的行为:
v = {}
vs = [v, v, v, v]
v1, *_, v4 = pickle.loads(pickle.dumps(vs))
v1 is v4
## True
(v1_, v2_), (v3_, v4_) = (
pickle.loads(pickle.dumps(vs[:2])),
pickle.loads(pickle.dumps(vs[2:]))
)
v1_ is v4_
## False
v3_ is v4_
## True
在同一个批处理引用中序列化的值,在 unpickling 之后,同一个对象。来自不同批处理的值指向不同的对象。
在实践中,Spark 有多个序列化和不同的序列化策略。例如,您可以使用无限大小的批处理:
from pyspark.serializers import BatchedSerializer, PickleSerializer
rdd_ = (sc.parallelize(range(10), 1).map(lambda _: bd.value)
._reserialize(BatchedSerializer(PickleSerializer())))
rdd_.cache().count()
rdd_.map(id).distinct().count()
## 1
您可以通过将 serializer
和/或 batchSize
参数传递给 SparkContext
构造函数来更改序列化器:
sc = SparkContext(
"local", "bar",
serializer=PickleSerializer(), # Default serializer
# Unlimited batch size -> BatchedSerializer instead of AutoBatchedSerializer
batchSize=-1
)
sc.serializer
## BatchedSerializer(PickleSerializer(), -1)
选择不同的序列化器和批处理策略会导致不同的权衡(速度、序列化任意对象的能力、内存要求等)。
您还应该记住,Spark 中的广播变量不会在执行线程之间共享,因此同一个 worker 可以同时存在多个反序列化副本。
此外,如果您执行需要改组的转换,您会看到与此类似的行为。
关于python - 正确使用大广播变量的技巧?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/37468405/
谁能给我提供代码或链接,以便在可能的情况下使用 UDP 发送和接收广播消息? 我一直被困在一个问题中,希望你们能帮助我解决它。谢谢 最佳答案 这是一个 C# 示例: using System; usi
我想将形状为 [a,b,c] 的张量中的元素相乘,每个元素在第 3 维中使用来自形状为 [a,b] 的张量的标量。 例如, x = |[1,2][3,4][5,6]| |[1,2][3,4][5,6]
广播是使具有不同形状的数组具有用于算术运算的兼容形状的过程。在 numpy 中,我们可以广播数组。 TensorFlow 图是否支持类似于 numpy 的广播? 最佳答案 是的,它是支持的。打开终端并
我有一个刷新功能,需要广播到子 Controller 。我在父 Controller 中做了类似的事情: // Refresh/Cancel $scope.OnGridBODRefre
我正在尝试在计算中使用字典值,如下所示: mydict = dict(zip(['key1', 'key2', 'key3'], [1, 2, 3])) print
刚刚掌握使用 MPI 的 Java 接口(interface)进行并行编程。只是想知道是否有人可以非常简单地解释广播的工作原理? 我有以下内容: if (me ==0) { // This is th
我正在处理一个项目,当我发送消息时,我将它作为通知发送给另一个用户使用广播它工作正常但是当我再次发送新消息然后替换为旧通知而不创建新通知 下面是我生成通知的代码 NotificationCompat.
我是 android 的初学者。但我非常需要你的帮助。我有一个流媒体视频广播视频项目。我找不到好的示例,在哪里可以实现从摄像机录制视频、将流发送(上传)到服务器以及从服务器下载(获取流)到播放器。请帮
请帮我解决我的问题。当我从父 Controller 调用并在子 Controller 中捕获时,为什么 $broadcast 函数不起作用?
我如何从 shell 中看到设置了哪些套接字选项?我特别想知道是否设置了 SO_BROADCAST? 最佳答案 你看过lsof了吗? 关于linux - 广播 socket ,我们在Stack Ove
当我在 Numpy 中进行此操作时会发生什么? a = np.ones([500,1]) b = np.ones([5000,])/2 c = a + b # a.shape (500,1) # b.
我有一个 Nexus S,当我在手机上手动更改日期时,并不总是广播 ACTION_DATE_CHANGED。如果我将日期从 2014 年 2 月 13 日更改为 2014 年 2 月 14 日,我还没
环境:springboot2.3.9RELEASE + RocketMQ4.8.0 依赖 <dependency>  
UDP 广播 面向连接的传输(如 TCP)管理两个网络端点之间的连接的建立,在连接的生命周期的有序和可靠的消息传输,以及最后,连接的有序终止。相比之下,类似 UDP 的无连接协议中则没有持久化连接的概
我正在开发一个带有 Angular 的单页应用程序,我需要在两个不同的指令之间进行通信,这些指令基本上没有父子关系。 在指令 A 中,我有 2 个地方需要从不同的功能广播相同的事件。在指令 B 中,为
我有一个带有多个重复项的主要二维 numpy 数组和一个具有第一个唯一值的辅助数组。 [[ 0 0 1 ] [ 1 0 2 ] [ 2 0 2 ] ... [ 0 0 1 ]
我正在制作多人网络游戏。现在要连接到服务器,客户端需要服务器的 ip 地址。 所以,我的实现方式如下。 客户端在广播 IP 和端口 A 上广播其 IP 地址。服务器通过 A 监听它,并且 服务器与客户
是否可以在没有 Urban Airship 等服务的情况下广播推送通知? 谢谢。 最佳答案 当然可以,但是您需要自己实现整个基础架构。 http://developer.apple.com/libra
我想复制矩阵的每一行 M没有任何复制发生(即通过创建 View ): 0 1 0 1 2 3 -> 0 1 2 3
我从一个 2D 数组开始,想将它广播到一个 3D 数组(例如,从灰度图像到 rgb 图像)。这是我使用的代码。 >>> img_grey = np.random.randn(4, 4) >>> img
我是一名优秀的程序员,十分优秀!