Trung tâm cá nhân
Điều phát hành
từ bỏ
Bài viết phổ biến của tác giả
- c - 在位数组中找到第一个零
- linux - Unix 显示有关匹配两种模式之一的文件的信息
- 正则表达式替换多个文件
- linux - 隐藏来自 xtrace 的命令
27
4
我需要优化我的应用程序的 RAM 使用率。
请省去那些告诉我在编写 Python 代码时不应该关心内存的讲座。我有内存问题，因为我使用非常大的默认字典(是的，我也想快点)。我目前的内存消耗是 350MB 并且还在增长。我已经无法使用共享主机，如果我的 Apache 打开更多进程，内存就会翻倍和三倍……而且很昂贵。
我已经完成了广泛的分析并且我确切地知道我的问题出在哪里。
我有几个带有 Unicode 键的大型(> 100K 个条目)词典。字典从 140 字节开始并且增长很快，但更大的问题是键。 Python 优化内存中的字符串(或者我读过的)，以便查找可以是 ID 比较(“实习”它们)。不确定 unicode 字符串也是如此(我无法“实习”它们)。
字典中存储的对象是元组列表(an_object, an int, an int)。
my_big_dict[some_unicode_string].append((my_object, an_int, another_int))
我已经发现拆分成多个字典是值得的，因为元组占用大量空间...
我发现我可以通过在将字符串用作键之前对字符串进行哈希处理来节省 RAM!但遗憾的是，我在 32 位系统上遇到了生日冲突。 (附带问题:是否有可以在 32 位系统上使用的 64 位 key 字典？)
Linux(生产)和 Windows 上的 Python 2.6.5。关于优化字典/列表/元组的内存使用的任何提示？我什至想到了使用 C——我不在乎这一小段代码是否丑陋。它只是一个单一的位置。
Cảm ơn trước!
câu trả lời hay nhất
我建议如下:将所有值存储在数据库中，并在内存中保留一个字典，其中字符串哈希作为键。如果发生冲突，则从数据库中获取值，否则(绝大多数情况)使用字典。实际上，它将是一个巨大的缓存。
Python 中字典的一个问题是它们占用大量空间:即使是 int-int 字典在 32 位系统上每个键值对也使用 45-80 字节。同时，array.array('i') 每一对整数仅使用 8 个字节，通过一些簿记，可以合理地实现基于数组的快速 int → int 字典。
一旦你有一个内存高效的 int-int 字典实现，将你的 string → (object, int, int) 字典分成三个字典并使用散列而不是完整的字符串。你会得到一个 int → object 和两个 int → int 字典。如下模拟 int → object 字典:保留对象列表并将对象的索引存储为 int → int 字典的值。
我确实意识到获取基于数组的字典涉及大量编码。我遇到了与您类似的问题，并且我已经实现了一个相当快、非常节省内存的通用散列整数字典。 Here's my code (BSD 许可证)。它是基于数组的(每对 8 个字节)，它负责 key 散列和冲突检查，它在写入期间保持数组(实际上是几个较小的数组)的顺序，并在读取时进行二进制搜索。您的代码被简化为:
dictionary = HashIntDict(checking = HashIntDict.CHK_SHOUTING)
# ...
database.store(k, v)
thử:
dictionary[k] = v
except CollisionError:
vượt qua
# ...
thử:
v = dictionary[k]
except CollisionError:
v = database.fetch(k)
checking 参数指定发生冲突时发生的情况:CHK_SHOUTING 在读取和写入时引发 CollisionError，CHK_DELETING 在读取时返回 Không có，在写入时保持沉默，CHK_IGNORING 不进行碰撞检查。
下面简单介绍一下我的实现，欢迎指点优化!顶级数据结构是数组的常规字典。每个数组最多包含 2^16 = 65536 个整数对(2^32 的平方根)。键 tôi 和相应的值 v 都存储在第 k/65536 数组中。数组按需初始化并按键保持排序。二进制搜索在每次读取和写入时执行。碰撞检查是一个选项。如果启用，覆盖现有键的尝试将从字典中删除键和关联值，将键添加到一组冲突键中，并(再次，可选)引发异常。
关于内存优化的 Python 技巧，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3021264/
27
4
0
Tôi đang chạy trên máy chạy Ubuntu c3.large Amazon EC2 với 2CPU và 3,75GB RAM (https://aws.amazon.com/ec2/instance-types/)
Tôi muốn ghi vào bộ nhớ VGA (bộ nhớ video, không phải bộ đệm) từ không gian người dùng bằng cách mmap-ing trong không gian người dùng và gửi địa chỉ đến không gian kernel, tôi sẽ sử dụng pfn remap để ánh xạ các địa chỉ mmap-ed này vào bộ nhớ vga (Tôi sẽ chuyển lspci
Trong Mathematica, nếu bạn muốn một hàm ghi nhớ giá trị của nó thì về mặt cú pháp, việc đó rất dễ dàng. Ví dụ: đây là ví dụ tiêu chuẩn - Fibonacci: fib[1] = 1 fib[2] = 1 fib[n_]:= fib[n] =
Tôi đọc rằng bộ nhớ động được phân bổ trên heap khi chạy, trong khi bộ nhớ tĩnh được phân bổ trên ngăn xếp tại thời điểm biên dịch, vì trình biên dịch biết phải phân bổ bao nhiêu bộ nhớ tại thời điểm biên dịch. Hãy xem đoạn mã sau: int n; cin>>n; int a[n]; nếu chỉ đọc trong thời gian chạy
Tôi mới làm quen với Python nhưng trước đây tôi chưa biết điều này. Tôi có một chương trình cơ bản trong vòng lặp for yêu cầu dữ liệu từ một trang web và lưu nó vào một tệp văn bản nhưng khi tôi kiểm tra trình quản lý tác vụ của mình, tôi thấy rằng mức sử dụng bộ nhớ chỉ tăng lên? Khi chạy trong một thời gian dài, điều này hiệu quả với tôi
Tôi đang thiết kế một tập hợp các hàm toán học và triển khai chúng trong cả phiên bản CPU và GPU (sử dụng CUDA). Một số hàm này dựa trên các bảng tra cứu. Hầu hết các bảng chiếm 4KB, một số chiếm nhiều hơn. Hàm dựa trên bảng tra cứu chấp nhận đầu vào và chọn một hoặc hai mục của bảng tra cứu,
Khi một tệp được đọc vào, bộ nhớ sẽ được phân bổ động vào một chuỗi và nội dung tệp sẽ được đặt ở đây. Việc này được thực hiện bên trong hàm, chuỗi được truyền dưới dạng char **str. Sử dụng gdb tôi thấy rằng ở dòng **(str+i) = fgetc(aFil
Tôi cần xác nhận một lý thuyết. Tôi đang học JSP/Java. Sau khi xem xét một ứng dụng hiện có (mà tôi không viết), tôi nhận thấy điều gì đó mà tôi tin rằng đang gây ra vấn đề về hiệu suất của chúng tôi. Hoặc ít nhất là một phần của nó. Đây là cách nó hoạt động: 1) Người dùng mở tìm kiếm
Tôi muốn sử dụng tính năng ghi nhớ để lưu vào bộ đệm kết quả của một số thao tác tốn kém nhất định để chúng không bị tính đi tính lại nhiều lần. Cả memoise và R.cache đều phù hợp với nhu cầu của tôi. Tuy nhiên, tôi nhận thấy rằng bộ nhớ đệm không đáng tin cậy giữa các cuộc gọi. Đây là bản demo tôi thấy đã hỏi
Tôi hiện đang phân tích một số mã shell javascript. Đây là một dòng trong tập lệnh: function có() { Memory = setTimeout("F0;
Tôi gặp tình huống muốn truy vấn cơ sở dữ liệu một lần rồi lưu toàn bộ dữ liệu vào bộ nhớ. Tôi đã nhận được đề xuất về Elaticsearch trong bộ nhớ và tôi đã tìm hiểu nó là gì cũng như cách triển khai nó trong ứng dụng khởi động mùa xuân của riêng tôi
Tôi đang giải quyết vấn đề 14 của Dự án Euler (http://projecteuler.net/problem=14). Tôi đang cố gắng sử dụng chức năng bộ nhớ để có thể lưu độ dài của một chuỗi các số đã cho dưới dạng kết quả một phần. Tôi
Vì vậy, tôi đang làm bài tập về trò chơi trí nhớ/sự chú ý bằng Java. Tôi vẫn chưa đạt được vị trí như mong muốn, mới chỉ hoàn thành được một nửa, nhưng tôi đã làm cho GUI hoạt động được phần lớn...cho đến khi tôi cố gắng thêm các nút radio vào khung của mình. Tôi nghĩ vấn đề có thể là do tôi đặt JF
Tôi đã cố gắng sử dụng tính năng ghi nhớ của Flask-Cache để chỉ trả về kết quả được lưu trong bộ nhớ cache của statusTS() trừ khi đáp ứng một điều kiện cụ thể trong một yêu cầu khác, sau đó xóa bộ đệm. Nhưng nó không bị xóa và mẫu Jinja vẫn còn
Tôi rất bối rối về cách sử dụng toán tử & để giảm bộ nhớ. Tôi có thể trả lời các câu hỏi dưới đây không? lớp C{ hàm B(&$a){ $this->a = &$a;
Trong khi viết mã, tôi gặp phải một vấn đề thú vị. Tôi có một PersonPOJO có tên là một trong các thành viên Chuỗi của nó và lớp getter và setter của nó PersonPOJO { priv
Trong mã này public class Base { int length, width, Height Base(int l, int b, int h) { l
Định nghĩa Đệm cấu trúc là quá trình căn chỉnh các thành viên dữ liệu của cấu trúc theo
Trong JavaScript Ninja secret, tác giả đề xuất giải pháp sau cho kết quả hàm bộ nhớ không cần đóng. Họ đã làm điều này bằng cách lợi dụng thực tế rằng hàm là đối tượng và xác định thuộc tính trên hàm để lưu trữ kết quả của các lệnh gọi hàm trong quá khứ
Tôi đang cố gắng tìm hiểu lượng RAM mà bản đồ tiêu thụ. Vì vậy, tôi đã làm như sau;- Map cr = crPair.collectAsMap(); // Hơn 200 mục System.out.printl
Tôi là một lập trình viên xuất sắc, rất giỏi!