相关疑难解决方法(0)

我试图在我的机器(1 Gb RAM 160 Gb HD Windows平台)上计算出最大程度上可以使用多少内存.

我读到malloc可以分配的最大内存仅限于物理内存(堆上).

此外,当程序超过内存消耗到某个级别时,计算机将停止工作,因为其他应用程序无法获得所需的足够内存.

所以要确认一下,我在C写了一个小程序:

int main(){  
    int *p;
    while(1){
        p=(int *)malloc(4);
        if(!p)break;
    }   
}

我希望有一段时间内存分配失败并且循环会中断,但是我的计算机挂起,因为它是一个无限循环.

我等了大约一个小时,最后我不得不强行关闭电脑.

一些问题:

• malloc是否也从HD分配内存？
• 上述行为的原因是什么？
• 为什么在任何时候都没有循环中断？
• 为什么没有分配失败？

我有一个CentOS服务器.系统是nginx/php-fpm.它有16GB RAM.CPU:8

CPU频率:2660.203 MHz

为什么我的错误日志中出现此错误？

php-fpm/error.log:

[02-Aug-2014 17:14:04]警告:[池www]似乎很忙(你可能需要增加pm.start_servers,或者pm.min/max_spare_servers),产生8个孩子,有0个空闲,总共21个孩子

这是我的www池的php-fpm配置:

php-fpm/www.conf:

pm =动态

pm.max_children = 32768

pm.start_servers = 10

pm.min_spare_servers = 10

pm.max_spare_servers = 10

pm.max_requests = 5000

如何解决问题？

我需要在C中获取当前进程的内存使用情况.有人可以在Linux平台上提供如何执行此操作的代码示例吗？

我知道cat /proc/<your pid>/status获取内存的方法,但我不知道如何在C中捕获它.

顺便说一句,这是我正在修改的PHP扩展(授予,我是C新手).如果PHP扩展API中有可用的快捷方式,那将更有帮助.

在运行带有2.6.32-22通用内核的Ubuntu 10.04的计算机上会出现以下问题:设置进程的驻留集大小(RSS)的限制似乎没有任何影响.我目前使用以下代码在Python中设置限制:

import resource
# (100, 100) is the (soft, hard) limit. ~100kb.
resource.setrlimit(resource.RLIMIT_RSS, (100, 100))
memory_sink = ['a']*10000000   # this should fail

列表memory_sink每次都成功.当我使用top检查RSS使用情况时,我可以轻松地使用1gb的RAM进程,这意味着限制无效.RSS限制不适用于此内核或发行版吗？如果有帮助,resource.RLIMIT_NPROC(用户进程限制)确实有效.

我正在尝试在Python中的父进程和子进程之间共享对象.为了解决这个想法,我创建了一个简单的Python脚本:

from multiprocessing import Process
from os import getpid

import psutil

shared = list(range(20000000))

def shared_printer():
    mem = psutil.Process(getpid()).memory_info().rss / (1024 ** 2)
    print(getpid(), len(shared), '{}MB'.format(mem))

if __name__ == '__main__':
    p = Process(target=shared_printer)
    p.start()
    shared_printer()
    p.join()

代码片段使用优秀的psutil库来打印RSS(驻留集大小).当我在OSX上用Python 2.7.15运行它时,我得到以下输出:

(33101, 20000000, '1MB')
(33100, 20000000, '626MB')

当我在Ubuntu上运行完全相同的代码片段(Linux 4.15.0-1029-aws#30-Ubuntu SMP x86_64 GNU/Linux)时,我得到以下输出:

(4077, 20000000, '632MB')
(4078, 20000000, '629MB')

请注意,子进程'RSS在OSX上是基本的0MB,与Linux中的父进程'RSS大小相同.我曾假设写入时复制行为在Linux中的工作方式相同,并允许子进程为大多数页面引用父进程的内存(可能除了存储对象头部的内存之外).

所以我猜测2系统中的写时复制行为存在一些差异.我的问题是:在Linux中我能做些什么来获得类似OSX的写时复制行为？

我正在尝试将大型json对象加载到内存中,然后对数据执行一些操作.但是,我注意到在读取json文件后RAM大幅增加 - 即使对象超出范围.

这是代码

import json
import objgraph
import gc
from memory_profiler import profile
@profile
def open_stuff():
    with open("bigjson.json", 'r') as jsonfile:
        d= jsonfile.read()
        jsonobj = json.loads(d)
        objgraph.show_most_common_types()
        del jsonobj
        del d
    print ('d')
    gc.collect()

open_stuff()

我尝试在Windows中使用Python版本2.7.12和Debian 9在Python版本2.7.13中运行此脚本,我发现Linux中的Python存在问题.

在Windows中,当我运行脚本时,它会在读取json对象时占用大量RAM,并且在范围内(如预期的那样),但是在操作完成后(如预期的那样)释放它.

list                       3039184
dict                       413840
function                   2200
wrapper_descriptor         1199
builtin_function_or_method 819
method_descriptor          651
tuple                      617
weakref                    554
getset_descriptor          362
member_descriptor          250
d
Filename: testjson.py

Line #    Mem usage    Increment   Line Contents
================================================
     5     16.9 MiB     16.9 MiB   @profile
     6                             def open_stuff():
     7 …

我还没有找到一种很好的方法来监视Python脚本的内存使用情况multiprocessing.更具体地说,我这样说:

import time

biglist = range(pow(10, 7))
time.sleep(5)

内存使用量为1.3 GB,由两者/usr/bin/time -v和top.但现在,说我这样做:

import time
from multiprocessing import Pool

def worker(x):
    biglist = range(pow(10, 7))
    time.sleep(5)
    return

Pool(5).map(worker, range(5))

现在top报告5 x 1.3 GB,这是正确的.但/usr/bin/time -v仍然报告1.3 GB,这是没有意义的.如果它正在测量父进程的消耗,那么应该说0.如果它正在测量父进程和子进程,那么它应该报告5 x 1.3 GB.为什么说1.3 GB？现在让我们尝试copy-on-write:

import time
from multiprocessing import Pool

biglist = range(pow(10, 7))

def worker(x):
    time.sleep(5)
    return

Pool(5).map(worker, range(5))

现在/usr/bin/time -v报告1.3 GB(再次),这是正确的.但top报告6 x 1.3 GB,这是不正确的.使用copy-on-write,它应该只报告1.3 GB.

如何使用multiprocessing？可靠地监视Python脚本的内存使用情况？

我试图setrlimit限制我在Linux系统上的内存使用,以阻止我的进程崩溃机器(我的代码崩溃了高性能集群上的节点,因为一个错误导致内存消耗超过100 GiB ).我似乎无法找到传递给他的正确资源setrlimit; 我认为它应该是常驻的,不能用setrlimit限制,但我对常驻,堆,堆栈感到困惑.在下面的代码中; 如果我只取消注释RLIMIT_AS,代码将失败MemoryError,numpy.ones(shape=(1000, 1000, 10), dtype="f8")即使该数组应该只有80 MB.如果我只取消注释RLIMIT_DATA,RLIMIT_RSS或RLIMIT_STACK两个阵列获得成功分配,即使总内存使用量为2 GB,或两次所需的最大.

我想让我的程序一旦尝试分配太多RAM就失败(无论如何).为什么所有的RLIMIT_DATA,RLIMIT_RSS,RLIMIT_STACK和RLIMIT_AS做什么,我的意思是,什么是正确的资源传递给setrlimit？

$ cat mwe.py 
#!/usr/bin/env python3.5

import resource
import numpy

#rsrc = resource.RLIMIT_AS
#rsrc = resource.RLIMIT_DATA
#rsrc = resource.RLIMIT_RSS
#rsrc = resource.RLIMIT_STACK

soft, hard = resource.getrlimit(rsrc)
print("Limit starts as:", soft, hard)

resource.setrlimit(rsrc, (1e9, 1e9))

soft, hard = resource.getrlimit(rsrc)
print("Limit is now:", soft, …

我刚刚在一台12 MB的机器上执行了一个mallocs 13 MB的程序(QEMU Emulated!).不仅如此,我甚至浏览了记忆并填充了垃圾......

void 
large_mem(void) 
{
  #define LONGMEM  13631488
  long long *ptr = (long long *)malloc(LONGMEM);
  long long i;
  if(!ptr) {
     printf("%s(): array allocation of size %lld failed.\n",__func__,LONGMEM);
     ASSERT(0);
  }
  for(i = 0 ; i < LONGMEM ; i++ ) { 
    *(ptr+i)=i;
  }
  free(ptr);
}

这怎么可能 ？我期待一个分段错误.

谁能给我更准确地描述这个 Spark 参数以及它如何影响程序执行？我无法从文档中确切地看出这个参数“在幕后”的作用。

我试图了解我们正在尝试运行的大规模模拟的内存使用情况.当我运行它"ps"报告

USER    PID %CPU %MEM     VSZ    RSS TTY    STAT START   TIME COMMAND
myuser 5252 97.7  0.5 5751412 377392 ?      Rs   19:49   1:15 myprogram

我们在该模拟中有三个阵列,每个阵列占用1.6gb(2亿个双打).根据中的信息

什么是Linux内存管理中的RSS和VSZ

我预计内存将被列在RSS下,但RSS只有377MB.根据stackoverflow线程中的信息,我得出结论,必须换掉内存并查看"free -m"

             total       used       free     shared    buffers     cached
Mem:         64391       5985      58406          0        463       1295
-/+ buffers/cache:       4226      60164
Swap:         4766          0       4766

和交换根本没用!除了它无论如何它太小的事实.那么RSS与VSZ的差异来自哪里呢？为什么我们分配VSZ的一部分而不是RSS的一部分呢？

我感谢所有的帮助

我们正在监控 jvm 指标，如堆、元空间、线程和 gc 计数，我们能够将这些指标推送到监控服务器，如 prometheus。类似地，我们想跟踪 Java 本机内存指标（jcmd VM.sumary 的输出）。我的问题是，是否可以通过调用任何 jvm 运行时类来获取这些指标？

我有一个运行带有以下jvm参数的java应用程序的容器:

-XX:+UseG1GC -Xms512m -Xmx2048m -XX:MaxPermSize=256m

我正在使用docker内存限制选项:

docker run -it -m 2304m foo bash

docker stats myApp在容器初始化之后运行会给我:

CONTAINER   CPU %    MEM USAGE/LIMIT     MEM %   NET I/O
myApp       0.17%  660.5 MB/2.416 GB    27.34%   240.8 kB/133.4 kB

但几个小时后我得到以下统计数据:

CONTAINER   CPU %    MEM USAGE/LIMIT     MEM %   NET I/O
myApp     202.18%  2.416 GB/2.416 GB   100.00%   27.67 GB/19.49 GB

虽然,如果我查看容器内正在运行的应用程序的进程执行细节,我有一个用法,~735MBmyApp继续计算请求没有任何问题:

me@docker-container ~]$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
me+          1  0.0  0.0  11636  1324 ?        Ss …