标签: pmap

我正试图找到我的内存在linux中运行的java进程的位置.有人建议我使用pmap -x来确切了解内存的作用.

输出真的很长,但基本上很好的一部分是重复这个:

00007fbf75f6a000    1016       -       -       - rwx--    [ anon ]
00007fbf76068000      12       -       -       - -----    [ anon ]

这到底是什么意思？为什么我有这么多的条目(4000+)？

关于该pmap函数的文档让我想知道如何通过Web获取XML提要集合的效率.我不知道pmap会产生多少并发获取操作以及最大值.

我试图使用pmap -x命令在Linux x86-64上查看进程的内存映射.看着pmap的输出我很困惑.特别是对于映射动态库的条目.它们有多个条目(实际上它们全部为4个,其中一些条目有3个条目).以下是一个例子

  Address           Kbytes   RSS   Dirty Mode   Mapping

00000036ca200000      88      64       0 r-x--  libpthread-2.5.so
00000036ca216000    2044       0       0 -----  libpthread-2.5.so
00000036ca415000       4       4       4 r----  libpthread-2.5.so
00000036ca416000       4       4       4 rw---  libpthread-2.5.so

每个库的第二行总是大小为2MB,而没有页面权限.在所有图书馆中,似乎它的RSS始终为零.最后两行也具有相同的大小(基页大小)和相同的权限(少数库没有rw映射).

有人对此有一些解释吗？我有点意识到,带有只读保护的映射可能由加载器完成,以读取库的元数据,而具有可执行权限的部分实际上是库的代码.我可能错了.

但我对这一中间行没有任何线索.没有许可,没有用法？谁在这里有一些智慧的话？

我还看到有几页报告在匿名内存上,没有任何模式位设置.这些代表什么？

Java中的"共享对象内存"和"堆内存"有什么区别.它是否像'共享对象内存'是'堆内存'的超集？

这个问题的来源是jmap的文档.它为打印'共享对象内存'和'堆内存'提供了不同的选项.

我运行以下简单程序

#include <stdio.h>
#include <stdlib.h>    
int
main() {
  malloc(1024*1024*32);
  getchar();
  return 0;
}

htop 给出这个

VIRT   RES   SHR
36684  312   240

pmap -x 给出这个

Address           Kbytes     RSS   Dirty Mode   Mapping
0000000000400000       0       4       0 r-x--  a.out
0000000000600000       0       4       4 r----  a.out
0000000000601000       0       4       4 rw---  a.out
00007f063d3b7000       0       4       4 rw---    [ anon ]
00007f063f3b8000       0     228       0 r-x--  libc-2.12.1.so
00007f063f532000       0       0       0 -----  libc-2.12.1.so
00007f063f731000       0      16      16 r----  libc-2.12.1.so
00007f063f735000       0       4       4 rw---  libc-2.12.1.so …

JDK版本是热点8u_45

我研究了我的 java 进程的本机内存。本机内存甚至比堆消耗更多的空间。然而，有许多本机内存块让我感到困惑。例如 pmap -x 的结果：

00007f8128000000   65508   25204   25204 rw---    [ anon ]
00007f812bff9000      28       0       0 -----    [ anon ]
00007f812c000000   65508   24768   24768 rw---    [ anon ]
00007f812fff9000      28       0       0 -----    [ anon ]
00007f8130000000   65508   25532   25532 rw---    [ anon ]
00007f8133ff9000      28       0       0 -----    [ anon ]
00007f8134000000   65524   22764   22764 rw---    [ anon ]
00007f8137ffd000      12       0       0 -----    [ anon ]
00007f8138000000   65508   26456   26456 rw---    [ anon ]
00007f813bff9000 …

使用多CPU核心的正确方法是什么jax.pmap？

以下示例在 CPU 核心后端上为 SPMD 创建环境变量，测试 JAX 是否识别设备，并尝试设备锁定。

import os
os.environ["XLA_FLAGS"] = '--xla_force_host_platform_device_count=2'

import jax as jx
import jax.numpy as jnp

jx.local_device_count()
# WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)
# 2

jx.devices("cpu")
# [CpuDevice(id=0), CpuDevice(id=1)]

def sfunc(x): while True: pass

jx.pmap(sfunc)(jnp.arange(2))

从jupyter内核执行并观察htop发现只有一个核心被锁定

htop当省略前两行并运行时，我收到相同的输出：

$ env XLA_FLAGS=--xla_force_host_platform_device_count=2 python test.py

替换sfunc为

def sfunc(x): return 2.0*x

并打电话

jx.pmap(sfunc)(jnp.arange(2))
# ShardedDeviceArray([0., 2.], dtype=float32, weak_type=True)

确实返回一个SharedDeviecArray.

显然我没有正确配置 JAX/XLA …

我已经在Julia工作了几个月了,我有兴趣并行写一些代码.我正在研究一个问题,我使用1个模型为几个不同的接收器生成数据(每个接收器的数据是一个向量).每个接收器的数据可以独立计算,这使我相信我应该能够使用pmap函数.我的计划是将数据初始化为2D SharedArray(每列代表1个接收器的数据),然后在每个列上进行pmap循环.但是我发现将SharedArray与pmap一起使用并不比使用map的串行工作快.我写了下面的虚拟代码来说明这一点.

@everywhere function Dummy(icol,model,data,A,B)
    nx = 250
    nz = 250
    nh = 50
    for ih = 1:nh
        for ix = 1:nx
            for iz = 1:nz
                data[iz,icol] += A[iz,ix,ih]*B[iz,ix,ih]*model[iz,ix,ih]
            end
        end
    end
end


function main()

    nx = 250
    nz = 250
    nh = 50

    nt = 500
    ncol = 100

    model1 = rand(nz,nx,nh)
    model2 = copy(model1)
    model3 = convert(SharedArray,model1)

    data1 = zeros(Float64,nt,ncol)
    data2 = SharedArray(Float64,nt,ncol)
    data3 = SharedArray(Float64,nt,ncol)

    A1 = rand(nz,nx,nh)
    A2 = copy(A1)
    A3 = convert(SharedArray,A1)

    B1 = rand(nz,nx,nh) …

我在docker容器内的Java 8上运行了一个java应用程序.该过程启动Jetty 9服务器并部署Web应用程序.传递以下JVM选项:-Xms768m -Xmx768m.

最近我注意到这个过程耗费了大量的内存:

$ ps aux 1
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
app          1  0.1 48.9 5268992 2989492 ?     Ssl  Sep23   4:47 java -server ...

$ pmap -x 1
Address           Kbytes     RSS   Dirty Mode  Mapping
...
total kB         5280504 2994384 2980776

$ jcmd 1 VM.native_memory summary
1:

Native Memory Tracking:

Total: reserved=1378791KB, committed=1049931KB
-                 Java Heap (reserved=786432KB, committed=786432KB)
                            (mmap: reserved=786432KB, committed=786432KB) 

-                     Class (reserved=220113KB, committed=101073KB)
                            (classes #17246)
                            (malloc=7121KB #25927) 
                            (mmap: …

我的问题很简单：

我正在一台小型笔记本电脑上进行编码，并且正在使用jax.pmap因为我的代码将在多个 TPU 上运行。我想“假装”拥有多个设备来测试我的代码并尝试不同的事情。

有什么办法可以做到吗？但我怀疑 Jax 内部是否能找到解决方案。谢谢！