相关疑难解决方法(0)

我试图了解多处理优于线程的优势.我知道多处理可以解决Global Interpreter Lock问题,但是还有什么其他优点,并且线程不能做同样的事情？

在下面的示例中,我有一些关于内存使用的相关问题.

1. 如果我在翻译中跑,

   foo = ['bar' for _ in xrange(10000000)]
   

   Run Code Online (Sandbox Code Playgroud)

   我机器上使用的真实内存最多80.9mb.然后,我

   del foo
   

   Run Code Online (Sandbox Code Playgroud)

   真正的记忆力下降,但仅限于30.4mb.解释器使用4.4mb基线,那么不26mb向OS 释放内存的优势是什么？是因为Python"提前规划",认为你可能会再次使用那么多内存吗？

2. 为什么它会50.5mb特别释放- 基于此发布的金额是多少？

3. 有没有办法强制Python释放所有使用的内存(如果你知道你不会再使用那么多内存)？

注意 这个问题不同于我如何在Python中明确释放内存？ 因为这个问题主要处理从基线增加内存使用量,即使在解释器通过垃圾收集(使用gc.collect或不使用)释放对象之后.

我正在阅读Python内存管理,并希望减少我的应用程序的内存占用.有人建议,子程序在减轻问题方面会有很长的路要走; 但我无法概念化需要做什么.有人可以提供一个简单的例子来说明如何...

def my_function():
    x = range(1000000)
    y = copy.deepcopy(x)
    del x
    return y

@subprocess_witchcraft
def my_function_dispatcher(*args):
    return my_function()

...进入一个真正的子处理函数,不存储额外的"自由列表"？

奖金问题:

这个"自由列表"概念是否也适用于python c-extensions？

原标题:Python内存泄漏打开文件<128KB？

原始问题

我在运行Python脚本时看到了我认为的内存泄漏.这是我的脚本:

import sys
import time


class MyObj(object):
    def __init__(self, filename):
        with open(filename) as f:
            self.att = f.read()


def myfunc(filename):
    mylist = [MyObj(filename) for x in xrange(100)]
    len(mylist)
    return []


def main():
    filename = sys.argv[1]
    myfunc(filename)
    time.sleep(3600)


if __name__ == '__main__':
    main()

主函数调用myfunc()创建一个包含100个对象的列表,每个对象打开并读取一个文件.从返回后myfunc(),我期望从100项列表中读取内存并从读取文件中释放,因为它们不再被引用.但是,当我使用该ps命令检查内存使用情况时,Python进程使用的内存比从第12行和第13行注释掉的脚本运行的Python进程多大约10,000 KB.

奇怪的是,内存泄漏(如果它就是这样)似乎只发生在大小<128KB的文件中.我创建了一个bash脚本来运行此脚本,文件大小从1KB到200KB,当文件大小达到128KB时内存增加停止.这是bash脚本:

#!/bin/bash

echo "PID RSS S TTY TIME COMMAND" > output.txt

for i in `seq 1 200`;
do
    python debug_memory.py "data/stuff_${i}K.txt" &
    pid=$!
    sleep 0.1
    ps -e -O rss …

我想使用管理命令对马萨诸塞州的建筑物进行一次性分析.我已经将违规代码减少为8行代码片段,演示了我遇到的问题.评论只是解释了为什么我要这样做.我在一个空白的管理命令中逐字地运行下面的代码

zips = ZipCode.objects.filter(state='MA').order_by('id')
for zip in zips.iterator():
    buildings = Building.objects.filter(boundary__within=zip.boundary)
    important_buildings = []
    for building in buildings.iterator():
        # Some conditionals would go here
        important_buildings.append(building)
    # Several types of analysis would be done on important_buildings, here
    important_buildings = None

当我运行这个确切的代码时,我发现内存使用量随着每个迭代外部循环而稳定增加(我print('mem', process.memory_info().rss)用来检查内存使用情况).

important_buildings即使在超出范围之后,列表似乎也会占用内存.如果我替换important_buildings.append(building)它_ = building.pk,它不再消耗大量内存,但我确实需要该列表进行一些分析.

所以,我的问题是:当它超出范围时,如何强制Python发布Django模型列表？

编辑:我觉得堆栈溢出有一点问题 - 如果我写了太多细节,没有人想花时间阅读它(它变成一个不太适用的问​​题),但如果我写得太少细节,我冒险忽略部分问题.无论如何,我真的很感激答案,并计划在本周末尝试一些建议,当我终于有机会回到这里!

我试图迭代超过100,000个图像并捕获一些图像功能，并将所得的dataFrame作为pickle文件存储在磁盘上。

不幸的是，由于RAM的限制，我被迫将图像分成20,000个大块并对其进行操作，然后再将结果保存到磁盘上。

在开始循环以处理下一个20,000图像之前，下面编写的代码应该保存20,000图像的结果数据框。

但是-这似乎没有解决我的问题，因为在第一个for循环结束时内存没有从RAM中释放

因此，在处理第50,000条记录时，该程序由于内存不足错误而崩溃。

在将对象保存到磁盘并调用垃圾收集器后，我尝试删除这些对象，但是RAM使用率似乎并未下降。

我想念什么？

#file_list_1 contains 100,000 images
file_list_chunks = list(divide_chunks(file_list_1,20000))
for count,f in enumerate(file_list_chunks):
    # make the Pool of workers
    pool = ThreadPool(64) 
    results = pool.map(get_image_features,f)
    # close the pool and wait for the work to finish 
    list_a, list_b = zip(*results)
    df = pd.DataFrame({'filename':list_a,'image_features':list_b})
    df.to_pickle("PATH_TO_FILE"+str(count)+".pickle")
    del list_a
    del list_b
    del df
    gc.collect()
    pool.close() 
    pool.join()
    print("pool closed")

我正在开发一个项目,涉及使用python来读取,处理和写入有时大到几百兆字节的文件.当我尝试处理一些特别大的文件时,程序偶尔会失败.它没有说'记忆错误',但我怀疑这是问题(实际上它根本没有理由失败').

我一直在测试较小文件上的代码并观察"顶部"以查看内存使用情况,并且通常达到60%.top说我的总内存为4050352k,所以3.8Gb.

同时我正在尝试使用以下一小段代码跟踪python本身的内存使用情况(请参阅我昨天的问题):

mem = 0
for variable in dir():
    variable_ = vars()[variable]
    try: 
        if str(type(variable_))[7:12] == 'numpy':
            numpy_ = True
        else:
            numpy_ = False
    except:
        numpy_ = False
    if numpy_:
        mem_ = variable_.nbytes
    else:
        mem_ = sys.getsizeof(variable)
    mem += mem_
    print variable+ type: '+str(type(variable_))+' size: '+str(mem_)
print 'Total: '+str(mem)

在我运行该块之前,我将所有不需要的变量设置为None,关闭所有文件和数字等等.在该块之后,我使用subprocess.call()来运行下一阶段所需的fortran程序.处理.在fortran程序运行时查看顶部显示fortran程序正在使用~100%的cpu和~5%的内存,而python正在使用0%的cpu和53%的内存.然而,我的一小段代码告诉我python中的所有变量加起来只有23Mb,应该是~0.5%.

那么发生了什么？我不希望那个小片段能给我一个关于内存使用情况的信息,但它应该准确到几Mb内吗？或者只是顶部没有注意到内存已经被放弃,但是如果有必要,它可以用于需要它的其他程序吗？

根据要求,这里是用尽所有内存的代码的简化部分(file_name.cub是一个ISIS3立方体,它是一个包含相同地图的5层(波段)的文件,第一层是光谱辐射,下一层4与纬度,经度和其他细节有关.这是我想要处理的火星图像.StartByte是我之前从.cub文件的ascii标题中读取的值,告诉我数据的起始字节,样本和Lines是地图的尺寸​​,也从标题中读取.):

latitude_array = 'cheese'   # It'll make sense in a moment
f_to = open('To_file.dat','w') 

f_rad = open('file_name.cub', 'rb')
f_rad.seek(0)
header=struct.unpack('%dc' % (StartByte-1), f_rad.read(StartByte-1))
header = None …

看来python3.5并没有完全释放任何已删除对象的内存,这可能是因为python内部维护某种memroy池以便重用目的,但是,我不想重用它们,我想让它们自由发挥内存可用于在linux上运行的其他程序.

>>> psutil.Process().memory_info().rss / 2**20
11.47265625
>>> d = {x:x for x in range(10**7)}
>>> psutil.Process().memory_info().rss / 2**20
897.1796875
>>> del d
>>> gc.collect()
0
>>> psutil.Process().memory_info().rss / 2**20
15.5859375

这只是一个玩具示例,真正的问题是在正在运行的服务器上,占用20GB的不合适内存.

这是另一个例子:(wd1是带字符串键的dict的dict)

>>> psutil.Process().memory_info().rss / 2**20
28.1796875
>>> wd1 = {x:{i:i for i in d} for x in k}
>>> psutil.Process().memory_info().rss / 2**20
682.78125
>>> del wd1
>>> psutil.Process().memory_info().rss / 2**20
186.21484375

我在Python中有一个相对较大的字典,并希望不仅能够从中删除项目,而且实际上从我的程序中的这些删除中回收内存.我正在遇到一个问题,虽然我从字典中删除项目甚至手动运行垃圾收集器,但Python似乎并没有释放内存本身.

一个简单的例子:

>>> tupdict = {}
# consumes around 2 GB of memory
>>> for i in xrange(12500000):
...   tupdict[i] = (i,i)
... 
# delete over half the entries, no drop in consumed memory
>>> for i in xrange(7500000):
...   del tupdict[i]
... 
>>> import gc
# manually garbage collect, still no drop in consumed memory after this
>>> gc.collect()
0
>>> 

我想现在发生的事情是,尽管条目被删除并且垃圾收集器运行,但Python不会继续并调整字典大小.我的问题是,有没有简单的方法,或者我可能需要更严肃地重新考虑我如何编写我的程序？

我的代码中遇到内存错误.我的解析器可以总结如下:

# coding=utf-8
#! /usr/bin/env python
import sys
import json
from collections import defaultdict


class MyParserIter(object):

    def _parse_line(self, line):
        for couple in line.split(","):
            key, value = couple.split(':')[0], couple.split(':')[1]
            self.__hash[key].append(value)

    def __init__(self, line):
        # not the real parsing just a example to parse each
        # line to a dict-like obj
        self.__hash = defaultdict(list)
        self._parse_line(line)

    def __iter__(self):
        return iter(self.__hash.values())

    def to_dict(self):
        return self.__hash

    def __getitem__(self, item):
        return self.__hash[item]

    def free(self, item):
        self.__hash[item] = None

    def free_all(self):
        for k in self.__hash:
            self.free(k)

    def …