Hi All,
I am trying to find the physical memory usage by each process/users.
Can you please let me know how to get the memory usage?.
Thanks,
bsraj.
tried top or prstat?
Because the memory is abstracted, you may not be able to find the physical mem itself, just overall mem used - which are you looking for?
HI,
I am trying to get the RAM usage by each process.
When i used TOP, i am able to get the total RAM used and the availabe memory as 100.. But we are having aroung 2G..
So i am trying to find how much each processes using the 2GB of memory.
Thanks,
bsraj.
Top does list processes too - in interactive mode (default behaviour of top), you can press 'o' then select what to sort by (such as 'res' or 'size') to see the big memory users.
Alternatively, prstat also shows the memory usage of the processes.
If you are using GUI, you can use SMC.
There is all information you have asked in graphical interface.
Hi,
Thanks for all the details.
Yes, i used the Top command and when i sum up the memory usage shown (such as 'res' or 'size') is becoming more than the RAM size. So i am not sure how to calculate the RAM usage be each processes..
Thanks,
Bsraj.
Hi,
No, I am not using the graphical window..
Thanks,
bsraj.
Unless I'm very wrong, they should sum up to the amount of virtual memory used (that includes any swap space too).
Consider two different users, each running the editor vi. Each process will have its own data segment and its own stack segment. But the two processes share a common text segment. And vi uses the standard I/O library, stdio. This is a shared library. One copy serves both vi processes. And it is probably serving dozens of other processes as well. Memory is not simply allocated to a process and the question really has no simple answer.
ps -eo pid,vsz,args | grep <pid>
This would give you the entire space occupied by the process
But there are two things you need to notice here.
1) Solaris memory works under Virtual Memory - which is RAM + Swap. Until and unless you really get into each and every file used by the program its really hard to find which is placed in RAM and which one in swap
2) As the above post says, some dynamic files are used by multiple processes. So if you go on adding all the files used by a process for all the processes, it will end up more than ur RAM + Swap
pmap <pid> will tell you all the files used by the process along with their addresses and space occupied. If you really want to dig inside the process, i suggest you use pmap to calculate
Thanks
~Sage
A frined of mine gave me that script some time ago, I modified it a bit, but it will work only in Linux, sorry for the off-topic, I just want to post it, because it's for the same subject I believe.
#!/usr/bin/env python
# Try to determine how much RAM is currently being used per program.
# Note per _program_, not per process. So for example this script
# will report RAM used by all httpd process together. In detail it reports:
# sum(private RAM for program processes) + sum(Shared RAM for program processes)
# The shared RAM is problematic to calculate, and this script automatically
# selects the most accurate method available for your kernel.
# Notes:
#
# A warning is printed if overestimation is possible, depending on the kernel specs.
#
# I don't take account of memory allocated for a program
# by other programs. For e.g. memory used in the X server for
# a program could be determined, but is not.
import sys, os, string
if os.geteuid() != 0:
sys.stderr.write("You must be root user to run this script!\n");
sys.exit(1)
PAGESIZE=os.sysconf("SC_PAGE_SIZE")/1024 #KiB
our_pid=os.getpid()
#(major,minor,release)
def kernel_ver():
kv=open("/proc/sys/kernel/osrelease").readline().split(".")[:3]
for char in "-_":
kv[2]=kv[2].split(char)[0]
return (int(kv[0]), int(kv[1]), int(kv[2]))
kv=kernel_ver()
have_smaps=0
have_pss=0
#return Rss,Pss,Shared
#note Private = Rss-Shared
def getMemStats(pid):
Shared_lines=[]
Pss_lines=[]
Rss=int(open("/proc/"+str(pid)+"/statm").readline().split()[1])*PAGESIZE
if os.path.exists("/proc/"+str(pid)+"/smaps"): #stat
global have_smaps
have_smaps=1
for line in open("/proc/"+str(pid)+"/smaps").readlines(): #open
#Note in smaps Shared+Private = Rss above
#The Rss in smaps includes video card mem etc.
if line.startswith("Shared"):
Shared_lines.append(line)
elif line.startswith("Pss"):
global have_pss
have_pss=1
Pss_lines.append(line)
Shared=sum([int(line.split()[1]) for line in Shared_lines])
Pss=sum([int(line.split()[1]) for line in Pss_lines])
elif (2,6,1) <= kv <= (2,6,9):
Pss=0
Shared=0 #lots of overestimation, but what can we do?
else:
Pss=0
Shared=int(open("/proc/"+str(pid)+"/statm").readline().split()[2])*PAGESIZE
return (Rss, Pss, Shared)
cmds={}
shareds={}
count={}
for pid in os.listdir("/proc/"):
try:
pid = int(pid) #note Thread IDs not listed in /proc/
if pid ==our_pid: continue
except:
continue
cmd = file("/proc/%d/status" % pid).readline()[6:-1]
try:
exe = os.path.basename(os.path.realpath("/proc/%d/exe" % pid))
if exe.startswith(cmd):
cmd=exe #show non truncated version
#Note because we show the non truncated name
#one can have separated programs as follows:
#584.0 KiB + 1.0 MiB = 1.6 MiB mozilla-thunder (exe -> bash)
# 56.0 MiB + 22.2 MiB = 78.2 MiB mozilla-thunderbird-bin
except:
#permission denied or
#kernel threads don't have exe links or
#process gone
continue
try:
rss, pss, shared = getMemStats(pid)
private = rss-shared
#Note shared is always a subset of rss (trs is not always)
except:
continue #process gone
if shareds.get(cmd):
if pss: #add shared portion of PSS together
shareds[cmd]+=pss-private
elif shareds[cmd] < shared: #just take largest shared val
shareds[cmd]=shared
else:
if pss:
shareds[cmd]=pss-private
else:
shareds[cmd]=shared
cmds[cmd]=cmds.setdefault(cmd,0)+private
if count.has_key(cmd):
count[cmd] += 1
else:
count[cmd] = 1
#Add max shared mem for each program
total=0
for cmd in cmds.keys():
cmds[cmd]=cmds[cmd]+shareds[cmd]
total+=cmds[cmd] #valid if PSS available
sort_list = cmds.items()
sort_list.sort(lambda x,y:cmp(x[1],y[1]))
sort_list=filter(lambda x:x[1],sort_list) #get rid of zero sized processes
#The following matches "du -h" output
#see also human.py
def human(num, power="Ki"):
powers=["Ki","Mi","Gi","Ti"]
while num >= 1000: #4 digits
num /= 1024.0
power=powers[powers.index(power)+1]
return "%.1f %s" % (num,power)
def cmd_with_count(cmd, count):
if count>1:
return "%s (%u)" % (cmd, count)
else:
return cmd
print " Private + Shared = RAM used\tProgram \n"
for cmd in sort_list:
print "%8sB + %8sB = %8sB\t%s" % (human(cmd[1]-shareds[cmd[0]]), human(shareds[cmd[0]]), human(cmd[1]),
cmd_with_count(cmd[0], count[cmd[0]]))
if have_pss:
print "-" * 33
print " %sB" % human(total)
print "=" * 33
print "\n Private + Shared = RAM used\tProgram \n"
#Warn of possible inaccuracies
#2 = accurate & can total
#1 = accurate only considering each process in isolation
#0 = some shared mem not reported
#-1= all shared mem not reported
def shared_val_accuracy():
"""http://wiki.apache.org/spamassassin/TopSharedMemoryBug"""
if kv[:2] == (2,4):
if open("/proc/meminfo").read().find("Inact_") == -1:
return 1
return 0
elif kv[:2] == (2,6):
if os.path.exists("/proc/"+str(os.getpid())+"/smaps"):
if open("/proc/"+str(os.getpid())+"/smaps").read().find("Pss:") != -1:
return 2
else:
return 1
if (2,6,1) <= kv <= (2,6,9):
return -1
return 0
else:
return 1
def current_memory_status():
print "Displaying currently available memory...\n"
print "--------------------------------------------------------------------------"
showSysMemory = 'free -lmt'
os.system(showSysMemory)
print "--------------------------------------------------------------------------"
print "\n"
current_memory_status()
vm_accuracy = shared_val_accuracy()
if vm_accuracy == -1:
sys.stderr.write("Warning: Shared memory is not reported by this system.\n")
sys.stderr.write("Values reported will be too large, and totals are not reported\n")
elif vm_accuracy == 0:
sys.stderr.write("Warning: Shared memory is not reported accurately by this system.\n")
sys.stderr.write("Values reported could be too large, and totals are not reported\n")
elif vm_accuracy == 1:
sys.stderr.write("Warning: Shared memory is slightly over-estimated by this system\n")
sys.stderr.write("for each program, so totals are not reported.\n")
Sample output report :
Check the pmap utility.