[CPyUG] python multiprocessing 多进程共享只读大对象

classic Classic list List threaded Threaded
18 messages Options
Reply | Threaded
Open this post in threaded view
|

[CPyUG] python multiprocessing 多进程共享只读大对象

Mails Academic
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

piglei
25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

zhao shichen
加载字典速度非常慢应该是因为需要解析这个字典造成的,也许可以考虑用解析速度快的格式保存这个字典。

kv数据库是一个主意;不过这么大的字典还真没用过。关注

在 2011年12月30日 上午10:08,piglei <[hidden email]>写道:
25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:

机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
呆痴木讷,君子四德

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

li donglin
Python有个库,叫做POSH,光看过介绍,没实际用过,可以参照参照:



在 2011年12月30日 上午10:30,zhao shichen <[hidden email]>写道:
加载字典速度非常慢应该是因为需要解析这个字典造成的,也许可以考虑用解析速度快的格式保存这个字典。

kv数据库是一个主意;不过这么大的字典还真没用过。关注

在 2011年12月30日 上午10:08,piglei <[hidden email]>写道:

25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:

机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
呆痴木讷,君子四德


--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
li donglin

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

依云
In reply to this post by Mails Academic
On Fri, Dec 30, 2011 at 12:41:36PM +1100, Mails Academic wrote:

> 机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65
>
> 问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G
> 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。
>
> 我搜索的相关信息:
> 1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
> 2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。
>
> 我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?
>
> 谢谢各位。

共享内存的速度应该是最快的,不过,Python 里怎么弄是个问题。

话说,既然是只读,创建子进程时这部分数据不是直接就共享了吗?

--
Best regards,
lilydjwg

Linux Vim Python 我的博客:
http://lilydjwg.is-programmer.com/
--
A: Because it obfuscates the reading.
Q: Why is top posting so bad?

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

QLeelulu Lee
In reply to this post by zhao shichen
同!直接放Redis不行?

在 2011年12月30日 上午10:30,zhao shichen <[hidden email]>写道:
加载字典速度非常慢应该是因为需要解析这个字典造成的,也许可以考虑用解析速度快的格式保存这个字典。

kv数据库是一个主意;不过这么大的字典还真没用过。关注

在 2011年12月30日 上午10:08,piglei <[hidden email]>写道:

25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:

机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
呆痴木讷,君子四德


--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
jyf
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

jyf
In reply to this post by Mails Academic
既然是只读,先用主进程加载数据 然后再fork各种工作进程吧

不过mmap方式更好

2011/12/30 Mails Academic <[hidden email]>
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
--
cheers
    Yunfan Jiang
{'nick':['jyf', 'geek42'], 'im': {'gtalk': '[hidden email]', 'irc': 'irc.freenode.net#ubuntu-cn'}, 'blog': 'http://geek42.info', 'interesting': {'teck': ['linux', 'pyt    hon', 'lua', 'c', 'nosql', 'redis', 'nginx'], 'history': ['chinese history',], 'sf': [42,], 'music': ['NewAge style', 'chinese old theme', 'Any strange music']}}

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

pansz-2
In reply to this post by Mails Academic
2011/12/30 Mails Academic <[hidden email]>:
> 我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

我感觉还是先把对象加载之后再 fork() 进程,是比较靠谱的办法。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Mails Academic
In reply to this post by piglei
谢谢大家的回复。

1. 用KV数据库的话,性能大概比直接访问字典慢多少呢?有粗略的数据可以提供么?
我的字典结构是:
dict:key = string,value= secondary dict
secondary dict: key=string, value= string
2. 有合适的KV数据库可以推荐么?

2011/12/30 piglei <[hidden email]>
25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。


--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Mails Academic
In reply to this post by QLeelulu Lee
谢谢,我试试Redis的性能,回来报告一下速度。

2011/12/30 QLeelulu Lee <[hidden email]>
同!直接放Redis不行?

在 2011年12月30日 上午10:30,zhao shichen <[hidden email]>写道:
加载字典速度非常慢应该是因为需要解析这个字典造成的,也许可以考虑用解析速度快的格式保存这个字典。


kv数据库是一个主意;不过这么大的字典还真没用过。关注

在 2011年12月30日 上午10:08,piglei <[hidden email]>写道:

25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:

机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
呆痴木讷,君子四德


--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Mails Academic
In reply to this post by li donglin
这个库在我的PC上可以用(32bit),而且很方便用。但是64bit机器上运行时会有segementation fault 错误。

2011/12/30 li donglin <[hidden email]>
Python有个库,叫做POSH,光看过介绍,没实际用过,可以参照参照:



在 2011年12月30日 上午10:30,zhao shichen <[hidden email]>写道:

加载字典速度非常慢应该是因为需要解析这个字典造成的,也许可以考虑用解析速度快的格式保存这个字典。

kv数据库是一个主意;不过这么大的字典还真没用过。关注

在 2011年12月30日 上午10:08,piglei <[hidden email]>写道:

25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面

在 2011年12月30日 上午9:41,Mails Academic <[hidden email]>写道:

机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
呆痴木讷,君子四德


--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html



--
li donglin

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Elias Soong-2
In reply to this post by Mails Academic
系统自带的 bsddb 。。有内存模式和磁盘模式。。多进程中只读不写应该没大问题。。

可以把键值改为 用“_”连接的一级键值和二级键值。。于是字典变成只有一级。。往 K-V 数据库里塞就简单多了。。

于 11-12-30 下午6:47, Mails Academic 写道:

> 谢谢大家的回复。
>
> 1. 用KV数据库的话,性能大概比直接访问字典慢多少呢?有粗略的数据可以提供么?
> 我的字典结构是:
> dict:key = string,value= secondary dict
> secondary dict: key=string, value= string
> 2. 有合适的KV数据库可以推荐么?
>
> 2011/12/30 piglei <[hidden email] <mailto:[hidden email]>>
>
>     25G都要加载在内存里吗?可以尝试存在一个key-value数据库里面
>
>     在 2011年12月30日 上午9:41,Mails Academic <[hidden email] <mailto:[hidden email]>>写道:
>
>         机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65
>
>         问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。
>
>         我搜索的相关信息:
>         1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
>         2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。
>
>         我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?
>
>         谢谢各位。
>
>
>         --
>         来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
>         规则: http://code.google.com/p/cpyug/wiki/PythonCn
>         发言: [hidden email] <mailto:[hidden email]>
>         退订: [hidden email] <mailto:python-cn%[hidden email]> (向此发空信即退!)
>         详情: http://code.google.com/p/cpyug/wiki/PythonCn
>         严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
>         强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
>
>
>     --
>     来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
>     规则: http://code.google.com/p/cpyug/wiki/PythonCn
>     发言: [hidden email] <mailto:[hidden email]>
>     退订: [hidden email] <mailto:python-cn%[hidden email]> (向此发空信即退!)
>     详情: http://code.google.com/p/cpyug/wiki/PythonCn
>     严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
>     强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
>
>
> --
> 来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
> 规则: http://code.google.com/p/cpyug/wiki/PythonCn
> 发言: [hidden email]
> 退订: [hidden email] (向此发空信即退!)
> 详情: http://code.google.com/p/cpyug/wiki/PythonCn
> 严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
> 强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Ma Ye
In reply to this post by Mails Academic
可以考虑用shelve
好处是跟你用内存的dict一样,程序改动小,不用每次启动花时间load, 坏处是多了转换的开销,这里多进程间的共享变为共享一个文件,很简单,很安全,diskIO 可以考虑把文件放到 memory disk里去.
上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

2011/12/29 Mails Academic <[hidden email]>
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Mails Academic
-- 上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,
-- 是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

我现在用的就是这种办法, jobs分配给了10个进程,只读大字典,程序是可以运行的(因为进程已经持续的print出结果)。
用top显示的S状态也是同时运行。如下图所示。
我在一个mailing list上也看到了关于引用计数修改引发拷贝的的表述,但是不知道为什么程序是可以运行的?

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                   
11282 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.67 python
11283 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.15 python
11284 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.38 python
11285 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.17 python
11286 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.20 python
11287 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.16 python
11288 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.97 python
11289 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.24 python
11290 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:41.43 python
11291 hanb      20   0 17.7g  16g 1160 R  100 26.8  91:24.30 python



2011/12/31 Ma Ye <[hidden email]>
可以考虑用shelve
好处是跟你用内存的dict一样,程序改动小,不用每次启动花时间load, 坏处是多了转换的开销,这里多进程间的共享变为共享一个文件,很简单,很安全,diskIO 可以考虑把文件放到 memory disk里去.
上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

2011/12/29 Mails Academic <[hidden email]>
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Ma Ye
当然可以运行,就是每个进程占用的内存会随着运行时间而上升,也就是进程间共享的部分在逐渐减少,如果你内存足够多当然不是问题,但是这么作的目的不就是为了节省内存么?
你可以作个实验,进程不干别的事,只是遍历一遍所有数据,所有的进程都干这个,你会发现,还是可以工作,不过disk swap会越来越频繁,直到失去你把数据放在内存里的优势。

2011/12/30 Mails Academic <[hidden email]>
-- 上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,
-- 是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

我现在用的就是这种办法, jobs分配给了10个进程,只读大字典,程序是可以运行的(因为进程已经持续的print出结果)。
用top显示的S状态也是同时运行。如下图所示。
我在一个mailing list上也看到了关于引用计数修改引发拷贝的的表述,但是不知道为什么程序是可以运行的?

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                   
11282 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.67 python
11283 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.15 python
11284 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.38 python
11285 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.17 python
11286 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.20 python
11287 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.16 python
11288 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.97 python
11289 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.24 python
11290 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:41.43 python
11291 hanb      20   0 17.7g  16g 1160 R  100 26.8  91:24.30 python



2011/12/31 Ma Ye <[hidden email]>
可以考虑用shelve
好处是跟你用内存的dict一样,程序改动小,不用每次启动花时间load, 坏处是多了转换的开销,这里多进程间的共享变为共享一个文件,很简单,很安全,diskIO 可以考虑把文件放到 memory disk里去.
上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

2011/12/29 Mails Academic <[hidden email]>
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

依云
On Fri, Dec 30, 2011 at 08:34:12PM -0800, Ma Ye wrote:
> 当然可以运行,就是每个进程占用的内存会随着运行时间而上升,也就是进程间共享的部分在逐渐减少,如果你内存足够多当然不是问题,但是这么作的目的不就是为了节省内存么?
> 你可以作个实验,进程不干别的事,只是遍历一遍所有数据,所有的进程都干这个,你会发现,还是可以工作,不过disk
> swap会越来越频繁,直到失去你把数据放在内存里的优势。

唉,拿 C 写个 ReadonlyDict 吧,里边数据就不用放 Python 对象了,也就不用
管引用计数了。

--
Best regards,
lilydjwg

Linux Vim Python 我的博客:
http://lilydjwg.is-programmer.com/
--
A: Because it obfuscates the reading.
Q: Why is top posting so bad?

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Mails Academic
In reply to this post by Ma Ye
HI, Ma Ye, 能解释一下为什么每个进程占用的内存会随着时间上升么,还有为什么disk swap会越来越频繁?谢谢


2011/12/31 Ma Ye <[hidden email]>
当然可以运行,就是每个进程占用的内存会随着运行时间而上升,也就是进程间共享的部分在逐渐减少,如果你内存足够多当然不是问题,但是这么作的目的不就是为了节省内存么?
你可以作个实验,进程不干别的事,只是遍历一遍所有数据,所有的进程都干这个,你会发现,还是可以工作,不过disk swap会越来越频繁,直到失去你把数据放在内存里的优势。


2011/12/30 Mails Academic <[hidden email]>
-- 上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,
-- 是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

我现在用的就是这种办法, jobs分配给了10个进程,只读大字典,程序是可以运行的(因为进程已经持续的print出结果)。
用top显示的S状态也是同时运行。如下图所示。
我在一个mailing list上也看到了关于引用计数修改引发拷贝的的表述,但是不知道为什么程序是可以运行的?

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                   
11282 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.67 python
11283 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.15 python
11284 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.38 python
11285 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.17 python
11286 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.20 python
11287 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:58.16 python
11288 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.97 python
11289 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:57.24 python
11290 hanb      20   0 17.7g  16g 1160 R  100 26.7  91:41.43 python
11291 hanb      20   0 17.7g  16g 1160 R  100 26.8  91:24.30 python



2011/12/31 Ma Ye <[hidden email]>
可以考虑用shelve
好处是跟你用内存的dict一样,程序改动小,不用每次启动花时间load, 坏处是多了转换的开销,这里多进程间的共享变为共享一个文件,很简单,很安全,diskIO 可以考虑把文件放到 memory disk里去.
上面有人说先load再fork,基于copy on write的机制,如果不改内容应该是进程间共享内存的,是最理想的办法,可惜python不是c,即使你不改内容,实例的引用计数还是会改,然后就copy了,然后你就会发现内存不够了。

2011/12/29 Mails Academic <[hidden email]>
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html
Reply | Threaded
Open this post in threaded view
|

Re: [CPyUG] python multiprocessing 多进程共享只读大对象

Marlon Yao
In reply to this post by Mails Academic
内存大也不用这么浪费啊!肯定得放文件系统啊,只读的字典最容易优化了,什么事务、锁基本都可以不要了,在网上搜一搜吧。我前不久才发现一个cdb, http://cr.yp.to/cdb.html,不过最多只支持4G大小的文件。

2011/12/30 Mails Academic <[hidden email]>
机器环境:64G内存,12核cpu,Ubuntu 10.04 LTS,Python 2.65

问题描述:我准备用多核多进程做一些简单处理,但是每个进程需要访问查找一个大字典(25G 内存),我不想每个进程都存一份字典拷贝,因为内存不够用。所以使用了manager.dict做进程共享资源,但是加载字典速度非常慢(要6个小时),大概比直接用字典慢了300倍。

我搜索的相关信息:
1)Python 自带的 manager.dict() 支持对字典对象的共享,但是加载速度太慢,而且没有试过加载后进程访问资源的速度如何。
2)因为子进程只拷贝父进程,我把字典加载放到了一个子进程中,然后实用xmlrpc做了一个服务,再在父进程中生成工作子进程,访问服务子进程。这样的内存消耗比较小,但是缺点是进程间服务通讯速度比较慢。

我的问题:对于多进程共享大的只读对象,有没有速度快的方法可以用?

谢谢各位。

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html

--
来自: python-cn`CPyUG`华蟒用户组(中文Python技术邮件列表)
规则: http://code.google.com/p/cpyug/wiki/PythonCn
发言: [hidden email]
退订: [hidden email] (向此发空信即退!)
详情: http://code.google.com/p/cpyug/wiki/PythonCn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
强烈: 建议使用技巧: 如何有效地报告Bug http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html