Skip to main content
 首页 » 编程设计

python之分布式调度程序中内存消耗过多的示例示例

2025年02月15日6shanyou

Dask示例,其中与线程调度程序相比,具有进程的调度程序需要过多的内存

你好,

我遇到了一个dask.array示例,其中线程(共享内存)调度程序(dask.get,dask.threaded.get)和带有工作进程的调度程序(dask.multiprocessing.get,distributed.Client().get)之间的计算时间和所需内存存在很大差异

我已经在带有SSD的2013 Core i7 16GB macOS Macbook Pro上测试了此设置。

当前的仿真在长度为ndims的许多dimlen向量之间实现了网格操作,然后对它们执行一些简单的元素运算,然后通过对各个维度求和得出最终结果。如果没有dask,示例将是这样的:网格数组的副本将与8*(dimlen**ndims)/1024**3 = 7.4 GByte一样大。因为我们有ndim = 3参数,所以如果所有操作都是由网格参数的普通副本完成的,则我们将需要超过16 GB的RAM。 (顺便说一句:如果通过numpy来访问示例,则无论如何numpy.broadcast_to和numpy.transpose不会创建完整副本。只有在创建res期间,才会分配完整的7.4 GByte数组。)

到目前为止,我了解到,多处理和分布式调度程序中的速度下降是由于大量的RAM消耗和某些任务而导致的,这些任务会写入磁盘(在分布式诊断网页上看到)。但是我无法解释这种行为,因为我目前对要计算的dask-graph的理解是:

使用dask的想法是通过使用dask.array进行分块来减少内存需求。假设为8*(chunklen**ndims)/1024**2 = 7.6 MByte,一个网格状参数块的最大副本数为float64。同样,在约简操作(一次一维)中,必须将大块块连接时,我们应该只以8*(dimlen/chunklen)*(chunklen**ndims)/1024**2 = 76 MByte的最大大块块结束。假设我们有4个进程,那么在任何给定时间,我们仍然只需要上述块大小的四倍即可。但是,资源监视显示这些调度程序涉及各种进程的16GB RAM的总消耗量。

我将对我在这里错过的确切内容进行更深入的解释,这将不胜感激。

预先感谢,马库斯

import numpy as np 
import dask.array as da 
from dask import get as single_threaded_get 
from dask.threaded import get as threaded_get 
from dask.multiprocessing import get as multiprocessing_get 
 
ndims = 3 
dimlen = 1000 
chunklen = 100 
 
# Some input data, which usually would come elsewhere 
xs = [np.random.randn(dimlen) for _ in range(ndims)] 
# Cast them to dask.array 
ys = [da.from_array(x, chunks=chunklen) for x in xs] 
# Meshgrid 
zs = [da.broadcast_to(y, ndims*(dimlen,)) for y in ys] 
zs = [da.rechunk(z, chunks=ndims*(chunklen,)) for z in zs] 
_a = tuple(range(ndims)) 
zs = [da.transpose(z, axes=_a[i:] + _a[:i]) for i, z in enumerate(zs)] 
 
# Some simple element-wise processing of n dimensional arguments 
res = zs[0] 
for z in zs[1:]: 
    res = res + z 
 
# Some reduction of all dimensions to a scalar 
for i in range(ndims): 
    res = da.sum(res, axis=-1) 
res 
 
dask.array<sum-aggregate, shape=(), dtype=float64, chunksize=()> 
 
len(list(res.dask.keys())) 
#12617 
 
%%timeit -n 1 -r 1 
x = res.compute(get=single_threaded_get) 
#10.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -n 1 -r 1 
x = res.compute(get=threaded_get) 
#7.32 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -n 1 -r 1 
x = res.compute(get=multiprocessing_get) 
#5h 14min 52s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
from distributed import Client 
client = Client() 
%%timeit -n 1 -r 1 
x = res.compute(get=client.get) 
#7min 37s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 

设定环境

用创建的Conda环境
$conda create -n py35 python=3.5 dask distributed jupyter 
$source activate py35 
$jupyter notebook . 
 
 
 
!conda list -e 
 
# This file may be used to create an environment using: 
# $ conda create --name <env> --file <this file> 
# platform: osx-64 
appnope=0.1.0=py35_0 
bleach=1.5.0=py35_0 
bokeh=0.12.5=py35_1 
chest=0.2.3=py35_0 
click=6.7=py35_0 
cloudpickle=0.2.2=py35_0 
dask=0.14.3=py35_0 
decorator=4.0.11=py35_0 
distributed=1.16.3=py35_0 
entrypoints=0.2.2=py35_1 
heapdict=1.0.0=py35_1 
html5lib=0.999=py35_0 
icu=54.1=0 
ipykernel=4.6.1=py35_0 
ipython=6.0.0=py35_1 
ipython_genutils=0.2.0=py35_0 
ipywidgets=6.0.0=py35_0 
jedi=0.10.2=py35_2 
jinja2=2.9.6=py35_0 
jsonschema=2.6.0=py35_0 
jupyter=1.0.0=py35_3 
jupyter_client=5.0.1=py35_0 
jupyter_console=5.1.0=py35_0 
jupyter_core=4.3.0=py35_0 
locket=0.2.0=py35_1 
markupsafe=0.23=py35_2 
mistune=0.7.4=py35_0 
mkl=2017.0.1=0 
msgpack-python=0.4.8=py35_0 
nbconvert=5.1.1=py35_0 
nbformat=4.3.0=py35_0 
notebook=5.0.0=py35_0 
numpy=1.12.1=py35_0 
openssl=1.0.2k=2 
pandas=0.20.1=np112py35_0 
pandocfilters=1.4.1=py35_0 
partd=0.3.8=py35_0 
path.py=10.3.1=py35_0 
pexpect=4.2.1=py35_0 
pickleshare=0.7.4=py35_0 
pip=9.0.1=py35_1 
prompt_toolkit=1.0.14=py35_0 
psutil=5.2.2=py35_0 
ptyprocess=0.5.1=py35_0 
pygments=2.2.0=py35_0 
pyqt=5.6.0=py35_2 
python=3.5.3=1 
python-dateutil=2.6.0=py35_0 
pytz=2017.2=py35_0 
pyyaml=3.12=py35_0 
pyzmq=16.0.2=py35_0 
qt=5.6.2=2 
qtconsole=4.3.0=py35_0 
readline=6.2=2 
requests=2.14.2=py35_0 
setuptools=27.2.0=py35_0 
simplegeneric=0.8.1=py35_1 
sip=4.18=py35_0 
six=1.10.0=py35_0 
sortedcollections=0.5.3=py35_0 
sortedcontainers=1.5.7=py35_0 
sqlite=3.13.0=0 
tblib=1.3.2=py35_0 
terminado=0.6=py35_0 
testpath=0.3=py35_0 
tk=8.5.18=0 
toolz=0.8.2=py35_0 
tornado=4.5.1=py35_0 
traitlets=4.3.2=py35_0 
wcwidth=0.1.7=py35_0 
wheel=0.29.0=py35_0 
widgetsnbextension=2.0.0=py35_0 
xz=5.2.2=1 
yaml=0.1.6=0 
zict=0.1.2=py35_0 
zlib=1.2.8=3 

@ kakk11建议的进一步跟进

你好@ kakk11,

非常感谢您的回答和努力。我对此进行了进一步的研究,如果将您的示例增加到我的问题的大小,即 ndims = 3, dimlen = 1000, chunklen = 100,我将得到以下行为,对于“慢速解决方案”,多处理调度程序又需要更长的时间。但是请记住,由于实际应用,我需要慢速解决方案的结构。
%%timeit -r 1 -n 1 
fast_solution(x).compute(get=single_threaded_get) 
# 2min 4s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -r 1 -n 1 
fast_solution(x).compute(get=threaded_get) 
# 49.5 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -r 1 -n 1 
fast_solution(x).compute(get=multiprocessing_get) 
# 55.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -r 1 -n 1 
slow_solution(x).compute(get=single_threaded_get) 
# 2min 21s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -r 1 -n 1 
slow_solution(x).compute(get=threaded_get) 
# 56.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 
 
%%timeit -r 1 -n 1 
slow_solution(x).compute(get=multiprocessing_get) 
# 10min 31s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 

您也可以尝试以下代码来查看两个版本的dask图之间的差异。 fast_solution直到最后都只包含并行路径,而 slow_solution具有更金字塔的结构。但是考虑到我对传递的单个块大小的考虑,我不明白问题出在哪里。
ndims = 2 
dimlen = 1000 
chunklen = 500  
# ... 
from dask.dot import dot_graph 
dot_graph(fast_solution(x).dask) 
dot_graph(slow_solution(x).dask) 

@mrocklin请求进一步跟进,以简化示例

您好@MRocklin,

感谢您的回答。我了解到,有些计算图具有很高的数据交换成本,并且手头的示例属于此类。我进一步简化了它,导致了二维的网格等效操作,然后将尺寸全部缩减为标量。也许这可以作为示例,让您对问题有更多的了解
  • distributed行为正常,并且该示例具有较高的数据交换成本
  • 我们可以提出一些简单的图形优化,以减轻
  • 问题
  • 如果是distributed调度程序的问题。

  • 请注意,该示例仅应用于分析内存使用情况,而不是CPU性能。由于这是一个简化的示例,因此不会为CPU产生足够的工作负载。

    我想强调的是,我之所以要关注此问题,是因为我有一个愿景,即dask/distributed应该能够处理图结构,其总数组大小的中间值远远超过 worker 的累积RAM,前提是块大小并且本 map 结构远低于工作人员RAM的容量。该示例实现了这样的图形结构。

    因此,这是更新的jupyter笔记本: dask_distributed_RAM_usage_meshgrid_operation.ipynb.zip

    期待有关该主题的更多讨论,并感谢您为此付出的努力。

    马库斯

    请您参考如下方法:

    感谢您进行有趣的测试。好像multiprocessing_get的总和超过列表有问题,我只能猜测为什么。默认情况下,dask.Bag中使用多处理,这是python对象而不是数组的用例,并且在需要进行进程间通信时不能快速执行。

    无论如何,当您在计算的所有步骤中使用dask函数时,它实际上在所有情况下都能快速运行,请参见我的示例

    import dask.array as da 
    from dask.multiprocessing import get as multiprocessing_get 
    import time 
     
    t0 = time.time() 
     
    ndims = 3 
    dimlen = 400 
    chunklen = 100 
     
    x = [da.random.normal(10, 0.1, size=ndims*(dimlen,), chunks=ndims*(chunklen,)) for k in range(ndims)] 
     
    def slow_solution(x): 
        res = x[0] 
        for z in x[1:]: 
            res = res + z 
        return da.sum(res) 
     
    def fast_solution(x): 
        return da.sum(da.stack(x)) 
     
    t1 = time.time() 
    print("start fast f-n") 
    fast_solution(x).compute(get=multiprocessing_get) 
     
    t2 = time.time() 
    print("start slow f-n") 
    slow_solution(x).compute(get=multiprocessing_get) 
     
    t3 = time.time() 
    print("Whole script: ", t3 - t0) 
    print("fast function: ", t2 - t1) 
    print("slow function: ", t3 - t2) 
    

    更新
    是否有特定的原因为什么您需要使用 multiprocessing_get而 threaded对您不起作用,或者您只是好奇? dask的文档并不十分全面,但是据我了解, multiprocessing解决方案通常用于dask Bag,它是任何种类的python对象的更通用解决方案。而且它的性能存在已知限制,请参见 http://dask.pydata.org/en/latest/shared.html#known-limitations