JRCMD
Hi,
By default, the jrcmd start_management_server and -Xmanagement java option both start up the
listener on all IPs instead of limiting it to the IP that is hosting the JVM. We have a large
number of app server instances running on each physical Linux host. This causes conflicts as soon
as we pass the -Xmanagment option to the second app server instance on a given physical server.
We are trying to standardize on Oracle Mission Control as both a Development and Production
Operation tool for capturing recording and identifying memory leaks and other issues. This
listener is required in order to remotely connect to the app server instance via Oracle Mission
Control
A successful solution would allow the IP as well as listener port for both the jrcmd
start_management_server and -Xmanagement options. Is this possible? If not, what is the correct
mechanism to turn on this listener without providing unique ports for each app server instance.
We have roughly 400 app server instances in production alone so assigning unique ports is not
desirable.
Any pointers in this regard would be highly appreciated.
Thanks
This is a limitation in the default remote JMX agent that we license from Sun and ship with JRockit. You can work around it by creating a custom management agent, which is not too difficult. More information here:
http://blogs.oracle.com/pacogomez/2007/11/monitoring_jrockit_through_a_f.html
and
http://download.oracle.com/docs/cd/E13150_01/jrockit_jvm/jrockit/tools/intro/mc_comm.html#wp999683¨
We are looking at providing a more flexible management agent in JRockit R28, which would resolve the problem you are facing. Can't share any details or dates here, though.
Regards,
Henrik
Similar Messages
-
JRockit jrcmd memprof how to use it
Hi,
I'm trying to investigate memory leak in aplication and come across jrcmd memprof tool which is said to be helpful for diagnosing such problems (http://download.oracle.com/docs/cd/E13188_01/jrockit/geninfo/diagnos/ctrlbreakhndlr.html).
Can some tell me how to read the result as it's quite big XML growing all the time? Is there any tool for interpreting the results? Where can I find definition of this XML and values persisted.
Is there any way to turn it off?
I googled "jrcmd memprof" but it seems as it's not used too often.
Cheers,
MikeMemleak is an online tool, so you cannot turn it on from WLDF you have to use JRMC and connect through that. However, you can get some memory data from JRA and you should be able to start a JRA recording from WLDF when the notification is raised, although I am not quite sure exactly how you do that - I refer to the WLDF documentation http://e-docs.bea.com/wls/docs103/wldf_configuring/, http://www.oracle.com/technology/products/weblogic/index.html
Edited by: TuvaPalm on Apr 21, 2009 7:56 AM -
Strange output from jrcmd print_memusage (R28)
Hi guys,
my jrcmd print_memusage tells me that my my heap is exactly the same size as my 'Compiled code' memory space:
Total mapped 3709432KB (reserved=1053884KB)
- Java heap 1048576KB (reserved=0KB)
- GC tables 35084KB
- Thread stacks 46848KB (#threads=162)
- Compiled code 1048576KB (used=50879KB)
- Internal 904KB
- OS 64836KB
- Other 641440KB
- Classblocks 47616KB (malloced=47354KB #116850)
- Java class data 772096KB (malloced=772015KB #557889 in 116850 classes)
- Native memory tracking 3456KB (malloced=1451KB #10)
This seems very weird to me, why would these 2 things be exactly the same?seems like a large amount of memory for compiled code but thanks for the response. Good to know the result is a sane one.
-
Unable to take hprof using jrcmd
Unable to take hprof using the below command
//../jrcmd 1234 hprofdump filename=/home/xyz/heapdump_2.hprof
1234:
1234: Unable to open socket file: target process not responding or HotSpot VM not loaded
- We checked that we were running as the same user who is running jvm
- We are able to take thread dump and it seems that the process is responding
Configuration:
Cheked glibc:
rpm -q --queryformat '\n%{NAME} %{VERSION} %{RELEASE} %{ARCH}\n' glibc
glibc 2.3.4 2.19 i686
jrockit release:
Oracle JRockit(R) R28.0.1-21-133393-1.6.0_20-20100512-2126-linux-ia32
OS:
*RHEL 4
Edited by: user12478552 on Feb 14, 2011 1:04 PMHi Gokul,
thanks for the reply
Since I used the mount command
mount -o username="Systemname\username" //192.168.100.206/SMRDBbkp /dump/smrbackup
So you mean to say the Systemname\username should have full permission. Right?
This username does have full permission.
WHat I think is, since we use the brtools in ORASID user hence it might have an issue?
Any help would be greatly appreciated -
I am on my Windows XP laptop and try to run jrcmd but it reports no pids. I am administrator of the machine.
1. start the java applet:
C:\bea\jrockit-R27.3.1-jdk1.5.0_11\demo\jfc\Notepad>java -jar Notepad.jar
2. run jrcmd in another cmd window:
C:\bea\jrockit-R27.3.1-jdk1.5.0_11\bin>jrcmd
C:\bea\jrockit-R27.3.1-jdk1.5.0_11\bin>Hi Eric,
Thanks for taking the time to update the thread based on our offline discussion.
For anyone else, this is how jrcmd works:
===
1a) When JR is started on Windows, it creates a file named <PID> in %TEMP%\hsperfdata_USERNAME. This is typically “C:\documents and settings\USERNAME\Local Settings\hsperfdata_USERNAME”.
1b) When JR starts on Linux/Windows it instead creates a file name <PID> in /tmp/hsperfdata_USERNAME.
2) When jrmcd starts, it searches the temp\hsperfdata_USERNAME directory for entries and uses that list to locate running JRockit instances.
3) When a JRockit process stops, it removes its entry. If it crashes, it will instead be cleaned up by the next JRockit started on the same machine by the same user.
I hope that helps your troubleshooting. Maybe %TEMP% has been undefined or there isn’t enough disk space on your Windows machine.
===
In Eric's case the problem might have been incorrect rights configured on the hsperfdata_USERNAME directory. Maybe something caused by a Unix-on-Windows tool like cygwin?
-- Henrik
Edited by hstahl at 10/24/2007 7:40 AM -
I am trying to use JRCMD from my JRockit 28.2.5\bin folder to do thread dumps from my WebLogic portal 10.3.2 windows envirnment. My managed servers start via nodemanager service. When I issue the command "JRCMD <pid> print_threads I get the message "insufficient memory or privileges to attach". I am running the command from a cmd line that is the same user that starts the nodemanager (which, subsequently start the managed server) and it gets the same error. Any ideas?
This issue was resolved after applying latest patch from Oracle.
-
Question on the JRockit Heap diagnostics information
Using the JRCMD, collected the JRockit Heap diagnostics data. Below is the output:
--------- Detailed Heap Statistics: ---------
69.5% 1240837k 316026 +1240837k [B
8.5% 133278k 1562216 +133278k [C
What does [B and [C stand for?
what process is occupying this much of memory? What is B and C?That's a good question.
It's a user unfriendly way to say to byte and character arrays ;) It should be changed.
From the VM spec:
B byte
C char
D double
F float
I int
J long
L<classname>; reference an instance of class <classname>
S short
Z boolean
[ one dimension array -
Startflightrecording: any way to get methods deeper stack traces?(dept 64)
I'm using jrcmd PID start_flightrecording in order to get some useful samplings, but it seems the stack traces are limited to depth 64 (i.e. in the Hot Methods's Predecessors view of JRockit Mission Control 4.1.0 I see only the last 64 frames) hence I miss important info about calling dynamics. I'm using jrockit-jdk1.6.0_37-R28.2.5-4.1.0. I've seen the [R27 version|http://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/jrdocs/refman/optionXX.html] supported a -XX:Tracedepth argument, but I don't see it on [R28 documentation|http://docs.oracle.com/cd/E15289_01/doc.40/e15062/toc.htm].
Any idea?
Kind regards
Davide
Edited by: user970531 on Apr 15, 2013 8:39 AMI'm using jrcmd PID start_flightrecording in order to get some useful samplings, but it seems the stack traces are limited to depth 64 (i.e. in the Hot Methods's Predecessors view of JRockit Mission Control 4.1.0 I see only the last 64 frames) hence I miss important info about calling dynamics. I'm using jrockit-jdk1.6.0_37-R28.2.5-4.1.0. I've seen the [R27 version|http://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/jrdocs/refman/optionXX.html] supported a -XX:Tracedepth argument, but I don't see it on [R28 documentation|http://docs.oracle.com/cd/E15289_01/doc.40/e15062/toc.htm].
Any idea?
Kind regards
Davide
Edited by: user970531 on Apr 15, 2013 8:39 AM -
JBoss EAP 6 On JRockit - Memory Leak
hello team.
I have memory leak problem on jboss and jrockit.
My Environment :
1. OS :
CentOS release 6.4 (Final)
2. JRockit :
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Oracle JRockit(R) (build R28.2.7-7-155314-1.6.0_45-20130329-0641-linux-x86_64, compiled mode)
3. Application Server:
JBoss EAP 6.2.0.GA
4. Application
Large EJB Application (100 and more EJB Beans (Stateless, Stateful, MDB, Timers and so on)
Everything works fine on older application server versions (4.3 , 4.2)
But now I have Problem
Of course I know that problem is new version - and i have discussion on JBoss forums.
but guys I have question about jrockit with you:
What is the option "Other" in memory ??
[jboss@jboss-new bin]$ jrcmd 17114 print_memusage
17114:
Total mapped 8457864KB (reserved=2983100KB)
- Java heap 3145728KB (reserved=0KB)
- GC tables 105232KB
- Thread stacks 46412KB (#threads=138)
- Compiled code 1048576KB (used=12257KB)
- Internal 1480KB
- OS 170324KB
- Other 3639056KB
- Classblocks 10496KB (malloced=9631KB #28393)
- Java class data 289536KB (malloced=192391KB #133697 in 28393 classes)
- Native memory tracking 1024KB (malloced=294KB #10)
[jboss@jboss-new bin]$
This size increases every time - and took entire amount of RAM.
Thank in Advance.
Regards,
Paata LominadzeNot sure what the 'other' is, but it is probably best shown by using an example. By using displayMap we can display a memory map of various JVM subsystems and libraries that are loaded, including third-party libraries.
./jrcmd 4523 print_memusage displayMap
Total mapped 3984796KB (reserved=2978740KB)
- Java heap 524288KB (reserved=0KB)
- GC tables 17548KB
- Thread stacks 20276KB (#threads=39)
- Compiled code 1048576KB (used=14224KB)
- Internal 1672KB
- OS 146924KB
- Other 2092648KB
- Classblocks 7424KB (malloced=7381KB #20064)
- Java class data 124416KB (malloced=124411KB #91048 in 20064 classes)
- Native memory tracking 1024KB (malloced=118KB #10)
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
OS *java r x 0x0000000000400000.( 76KB)
OS *java rw 0x0000000000612000.( 4KB)
OS *[heap] rw 0x00000000007c1000.( 132KB)
INT Poll r 0x000000007fffe000 ( 4KB)
INT Membar rw 0x000000007ffff000.( 4KB)
MSP Classblocks (1/2) rw 0x00000000df8c0000 ( 6912KB)
MSP Classblocks (2/2) rw 0x00000000dff80000 ( 512KB)
HEAP Java heap rw 0x00000000e0000000.( 524288KB)
OS *ld-2.12.so r x 0x0000003664400000.( 128KB)
OS *ld-2.12.so r 0x000000366461f000 ( 4KB)
OS *ld-2.12.so rw 0x0000003664620000 ( 4KB)
OS **ld-2.12.so rw 0x0000003664621000.( 4KB)
OS *gconv-modules.cache r 0x00007f8f2e4a0000 ( 28KB)
THREAD Stack 4630 rwx 0x00007f8f2e4a7000 ( 8KB)
THREAD Stack 4630 0x00007f8f2e4a9000 ( 12KB)
THREAD Stack 4630 rwx 0x00007f8f2e4ac000 ( 244KB)
MSP Java class data (5/37) rw 0x00007f8f2e4e9000 ( 14336KB)
MSP Java class data (9/37) rw 0x00007f8f2fa40000 ( 5888KB)
rw 0x00007f8f30000000 ( 188KB)
0x00007f8f3002f000 ( 65348KB)
rw 0x00007f8f34000000 ( 132KB)
0x00007f8f34021000 ( 65404KB)
rw 0x00007f8f38000000 ( 412KB)
0x00007f8f38067000.( 65124KB)
MSP Java class data (10/37) rw 0x00007f8f3c034000 ( 34048KB)
rw 0x00007f8f3e174000 ( 8200KB)
MSP Java class data (11/37) rw 0x00007f8f3e976000 ( 256KB)
OS *libhpi.so rw 0x00007f8fb37fc000 ( 8KB)
OS **libhpi.so rw 0x00007f8fb37fe000 ( 4KB)
CODE Compiled code rwx 0x00007f8fb37ff000 ( 64KB)
CODE Compiled code rwx 0x00007f8fb380f000 ( 128KB)
CODE Compiled code rwx 0x00007f8fb382f000 ( 64KB)
MSP Java class data (37/37) rw 0x00007f8ff83a1000 ( 512KB)
GC Modified Union Set (committed) rw 0x00007f8ff8421000 ( 132KB)
GC Card table rw 0x00007f8ff8442000 ( 1024KB)
GC Object bits (committed) rw 0x00007f8ff8542000 ( 8196KB)
Here
- thread is thread related (such as thread stacks)
- int, internal use (such as pointer pages)
- heap, chunk used by JRockit for the Java heap
- os, mapped directly from the operating system, such as third party DLLs or shared objects
- msp, memory space. a memory space is a native heap with a specific purpose, for example native memory allocation inside the JVM
- gc, garbage collection related, for example live bits
- code, compiled code
The 'other' memory space looks to me (from the blank entries in the above print-out) like they are a memory pages to are still not used. When the JVM starts it mappes an amount of memory. To my knowledge JRockit uses mmap (mmap(2) - Linux manual page), which creates a new mapping in the virtual address space. JRockit reserves an amount of memory (Java Heap (heap where your object instances go) + its own runtime (all the others)).
To see where the growth is in the various memory spaces, you can use 'print_memusage baseline', after which you can execute print_memusage again, for example,
./jrcmd 4523 print_memusage scale=M
4523:
Total mapped 3896MB +4MB (reserved=2905MB -3MB)
- Java heap 512MB (reserved=0MB)
- GC tables 17MB
- Thread stacks 19MB (#threads=39)
- Compiled code 1024MB (used=14MB +1MB)
- Internal 1MB
- OS 143MB
- Other 2043MB
- Classblocks 7MB (malloced=7MB #20596 +532)
- Java class data 126MB +4MB (malloced=125MB +4MB #93640 +2592 in 20596 classes)
- Native memory tracking 1MB (malloced=0MB #20 +10)
Note the additional column that prints out the difference in memory usage in relation to the baseline. You can also monitor native allocations by using trace_alloc_sites, memory allocations can then be displayed with different levels of detail using the level argument.
./jrcmd 4523 print_memusage trace_alloc_sites=true
4523:
Total mapped 3989660KB +4864KB (reserved=2974732KB -4008KB)
- Java heap 524288KB (reserved=0KB)
- GC tables 17548KB
- Thread stacks 20276KB (#threads=39)
- Compiled code 1048576KB (used=15265KB +1040KB)
- Internal 1672KB
- OS 146924KB
- Other 2092648KB
- Classblocks 7680KB +256KB (malloced=7669KB +287KB #20596 +532)
- Java class data 129024KB +4608KB (malloced=128967KB +4555KB #93640 +2592 in 20596 classes)
- Native memory tracking 1024KB (malloced=236KB +118KB #20 +10)
./jrcmd 4523 print_memusage level=3
4523:
Total mapped 3989660KB +4864KB (reserved=2974732KB -4008KB)
- Java heap 524288KB (reserved=0KB)
- GC tables 17548KB
- Thread stacks 20276KB (#threads=39)
- Compiled code 1048576KB (used=15265KB +1040KB)
- Internal 1672KB
- OS 146924KB
- Other 2092648KB
- Classblocks 7680KB +256KB (malloced=2KB -7379KB #4 -20060) Not fully traced
- Java class data 129024KB +4608KB (malloced=26KB -124385KB #16 -91032 in 20596 classes) Not fully traced.
- Native memory tracking 1024KB (malloced=118KB #10) Not fully traced.
gather_memorymap_database memtrace.c: 206 91KB +91KB (#1 +1)
gather_memory_usage osal_mspace.c:5142 7KB +7KB (#4 +4)
msGatherMSpacesUsageDatabase osal_mspace.c:6128 2KB +2KB (#1 +1)
msGatherMSpacesUsageDatabase osal_mspace.c:6134 16KB +16KB (#1 +1)
Note this is more on the JVM level, in your case in might be beneficial to investigate what is happening on the java heap. By using print_object_summary you can get insight how memory on the heap is used on a per-class basis. To get to the bottom of where the memory leak is you can use the memory-leak-detector (an example of its use can be found here Middleware Snippets: Fast, Faster, JRockit). You can also obtain a heapdump that can be analyzed by using for example MAT (see for an example here Middleware Snippets: Visualizing Class Loading). To obtain a heapdump you can run the command, for example,
[weblogic@machine1 bin]$ ./jrcmd 4523 runsystemgc full=true fullcompact=true
4523:
[weblogic@machine1 bin]$ ./jrcmd 4523 hprofdump filename=/home/weblogic/dump.hprof
4523:
Wrote dump to /home/weblogic/dump.hprof
Note that this first issues a full GC by using the runsystemgc command. -
JNI native threads causing JRE to fail to shut down?
Hello,
I am using JNI to communicate with a COM object. I am reasonably certain at this point that my JNI code is handling this properly and the third party COM library is releasing the object in question. We allocate and release hundreds of these objects and we aren't observing any memory leaks. Likewise in our handling of events we receive from the COM object. We attach the thread to Java, deliver the event, and then detach the thread from Java, with very careful error handling around the event delivery to ensure that whatever else happens the detach gets called. This code is very robust and stable in operation and has been working at load in the field for over a year now without any customer problems in the JNI area.
However, since day one, when I go to shut down the application, the JNI isn't winding down properly. As it happens, since the JRE is running a Tomcat, driven by a wrapper service, the wrapper eventually gives up waiting and shoots the JRE in the head, but the user experience of stopping the wrapper service is ugly and we'd like to clean that up. The JNI code, of course, runs as shared code in the Tomcat.
It is possible that the third-party library, which does network communications, is keeping a thread pool for use with any of the COM objects even after all COM objects are released. This would be experienced as a one-time hit when the first object is allocated and not as a continual leak, so we'd be unlikely to notice it otherwise.
Will native non-Java threads running in the JRE but not allocated by the JRE itself cause the JRE to hang on until they've spontaneously decided to clean themselves up? Threads that have never been attached to the JVM? How about threads that were briefly attached to the JVM but then detached? Any worse?
RalphHi Ralph,
I will need some more information regarding this issue.
1. What platform are you on?
2. Which JRockit version are you running?
3. If you remove the wrapper service, does JRockit freeze without exiting properly?
As a general recommendation I would try to upgrade to the latest JRockit version. It can be downloaded from the OTN http://www.oracle.com/technology/software/products/jrockit/index.html
You may also try some verbose printouts to debug the issue a little further. Try
-Xverbose:thread=debug,jni=debug
This might give us some more insight in what is going on.
Also when JRockit freezes you can output a Java stack trace using our 'jrcmd' tool which you can find in the same folder as the java executable. Run this tool without any parameters and it will output identifiers (numbers) for every running JRockit instance on your machine. Run the same tool again, this time append the identifier you believe is the one running the Tomcat and add the command 'print_threads', ie
jrcmd <some_id_here> print_threads
This may show what JRockit is waiting for.
Cheers,
/Henrik -
Hello all,
I'm not sure whether this post should be here or in WebLogic section, so correct me if I'm wrong.
I'm working on JDeveloper 11.1.1.3 while deployments are made on standalone WebLogic 10.3.3. This thing occurred in previous versions also.
With every deployment WebLogic increases it's used memory until the famous PermGen space error, which is after about 5-6 deployments.
I'm doing my best to understand how to use memleak detection tools. I've switched JDev and WL from Sun jdk which was used before to JRockit, same thing happens. Both JDev's memory profiler and JRockit mission control show something that I really do not understand. char[] uses around 30% of heap space and keeps growing with deployments, next is String with 8%. I never use char in app.
Am I looking at the wrong thing? Is it normal for char[] to increase on WebLogic on deployments? Does anyone know how to check other things and what to check? Someone on other forums mentioned it would be useful to check if ApplicationContext keeps initializing over again on deployments. Does anyone know how to check this?
One more thing, I have successfully deployed app on Tomcat, and Tomcat said there is a memory leak in app, but could not tell anything specific.
I'm kinda lost in this :(It is normal for the PermGen space of the Sun's JVM to get filled after several re-deployments. PermGen stands for "permanent generational". This space is used by classes that is unlikely to need to be garbage-collected, so they are placed in this memory space that is never garbage-collected (for example, the Class instances). When you redeploy an application, a new class loader instance is used and it instantiates new Class instances that fill up the PermGen space. But why this happens on JRockit either, I could not explain.
We have experienced memory leaks related to classes and components that use native memory. For example, we have had significant memory leak when using Oracle's JDBC OCI driver. We were not able to solve this problem, so we switched to JDBC Thin driver (which is very performant and stable today comparing to some years ago). If you are using Oracle JRockit, you can monitor the overall memory usage by the following JRockit command executed at OS command line:
jrcmd <jrockit_pid> print_memusage>where <jrockit_pid> should be replaced by the JVM process ID.
If you suspect existence of native memory leaks, then have a look at the article Thanks for the memory for explanations about how Java uses native memory.
Dimitar -
"Out of memory" error using SmartView v11.1.1.3.500, MS Excel 2007 & MS Win7 Prof SP1 (all 32-bit)
Hi All,
A user is regularly experiencing "Out of memory" error messages while retrieving large MS Excel 2007 worksheets (ad-hoc analysis; approx 700 rows by 13 columns) connected to a Planning cube via 32-bit SmartView v11.1.1.3.500 (Build 008) on a 32-bit MS Windows 7 Prof (SP1) computer with 4GB of RAM. The same user is reporting experiencing a number of other issues (eg, TCP-related time-out, unable to connect to the APS, SmartView add-in disappearing, etc) at the same time.
I could not locate any specific KB document from the My Oracle Support website which addressed these specific issues all at once but from various posts out there, the recommendations to address similar issues were as follows:
Tick the Options > Display > Reduce Excel file size option;
Tick the Options > Display > Improve metadata storage option;
Rebuild the MS Excel workbook from scratch;
Delete all temp files located in the C:\Users\USER NAME\AppData\Local\Temp directory;
Disable auto-recovery for MS Excel;
Add misc TCP-related registry entries (eg, TcpTimedWaitDelay, MaxUserPort, MaxFreeTcbs, etc) on both the client PC and server;
Adjust MS Windows for best performance;
Increase the page file by 25%-50% more than the physical amount of RAM installed on the client PC;
Relocate the page file to a different drive as compared to the drive where MS Windows is installed on the client PC;
On top of the above, are there any other recommendations anyone else would like to share to address the "Out of memory" issue?
Many thanks in advance,
JBMMonitor the Full GC in GC log and see if there is any gradual increase in the free memory retained after every Full GC over a period, if there is a gradual increase and if its reaching maximum specified heap over a period of time, that means there might be some slow leak from application or native libraries.
Also please check if you have any pattern or request which might be triggering OOM all of the sudden.
If its memory leak best way to investigate that is to capture JRA's at regular interval's and monitor top 10 objects and see which one is growing and consuming more % of heap over a period of time.
You can also have this by captured by print_object_summary and print_memusage options in JRCMD command over a period of time.
Hope this helps.
- Tarun -
-Xmx JVM parameter is not working as defined
Hello,
I am running BEA with Tomcat servlet engine & i have set the -Xmx setting to 1.2GB & the application data footprint is 700MB. But the weird thing is that as the application starts up & as it starts loading data into memory & grows the max setting -Xmx is being ignored by the JVM & it is streching upto the max size of 1.5GB allowed on a Win32 box.
So why is the JVM going beyond 1.2GB of heap size even when we have -Xmx set to 1.2GB.
Is there any other BEA JVM parameter needs to be used for this case ? Please help me ..
Thanks
Chandraupgrade is not that easy as this is a production machine - was there an issue with memory in this case for my version ?
running jrcmd, it reports 2.6 G of unaccounted memory...
$ ./jrcmd 13573 print_memusage
[JRockit] memtrace is collecting data...
[JRockit] *** 1th memory utilization report
(all numbers are in kbytes)
Total mapped ;;;;;;;6176320
; Total in-use ;;;;;;5066300
;; executable ;;;;; 103956
;;; java code ;;;; 9536; 10.1%
;;;; used ;;; 6213; 65.2%
;; shared modules (exec+ro+rw) ;;;;; 94382
;; guards ;;;;; 672
;; readonly ;;;;; 47396
;; rw-memory ;;;;;4924484
;;; Java-heap ;;;;2097152; 42.6%
;;; Stacks ;;;; 15643; 0.3%
;;; Native-memory ;;;;2811688; 57.1%
;;;; java-heap-overhead ;;; 68734
;;;; codegen memory ;;; 32
;;;; classes ;;; 25856; 0.9%
;;;;; method bytecode ;; 1769
;;;;; method structs ;; 2618 (#27935)
;;;;; constantpool ;; 5395
;;;;; classblock ;; 1005
;;;;; class ;; 1124 (#2274)
;;;;; other classdata ;; 2541
;;;;; overhead ;; 6334
;;;; threads ;;; 56; 0.0%
;;;; malloc:ed memory ;;; 36807; 1.3%
;;;;; codeinfo ;; 528
;;;;; codeinfotrees ;; 601
;;;;; exceptiontables ;; 877
;;;;; metainfo/livemaptable ;; 8291
;;;;; codeblock structs ;; 8
;;;;; constants ;; 11
;;;;; livemap global tables ;; 7071
;;;;; callprof cache ;; 0
;;;;; paraminfo ;; 77 (#993)
;;;;; strings ;; 2493 (#42793)
;;;;; strings(jstring) ;; 469
;;;;; typegraph ;; 564
;;;;; interface implementor list ;; 61
;;;;; thread contexts ;; 67
;;;;; jar/zip memory ;; 16252
;;;; unaccounted for memory ;;;2680257; 95.3%;72.82
---------------------!!! -
Object in cache count and total heap size consumed.
Hi
Can you please help me to extract - total number of custom value objects (count) and its total heap space consumed. How do we extract this information (from jrcmd or jrockit command control - jrockit jvm).
Do we need to use - com.tangosol.net.management.Registry? can you share some example/documentation in this regard.
Thanks
sunderHi NJ,
Thanks for your response - if I have to implement unit-calculator - i need to use instrumentation API to compute the size of a entry which will affect the performance of system.
Here is my problem.
1 - Have a com.tangosol.net.DefaultCacheServer (distributed cache) instance running
2 - A client joins the distributed cluster and inserts records into cluster and leaves the cluster.
when I do jrcmd on "DefaultCacheServer" i dont see any of custom java components (beans set distributed cache) - I want to have visibility of objects being put in cache and actual space consumed. Is there a way to get this?
[xx@yyy ~]$ jrcmd 10693 print_object_summary
10693:
--------- Detailed Heap Statistics: ---------
64.7% 6565k 2571 +6565k [B
10.2% 1034k 14816 +1034k [C
3.7% 374k 3199 +374k java/lang/Class
3.6% 364k 15560 +364k java/lang/String
2.8% 280k 3468 +280k [Ljava/lang/Object;
1.2% 119k 118 +119k [Lcom/tangosol/util/RecyclingLinkedList$Node;
1.0% 98k 2510 +98k com/tangosol/io/ByteArrayWriteBuffer
0.9% 94k 2418 +94k com/tangosol/run/xml/SimpleElement
0.8% 81k 2088 +81k com/tangosol/run/xml/SimpleElement$AttributeMap
0.8% 80k 696 +80k [Ljava/util/HashMap$Entry;
0.6% 64k 2740 +64k java/util/HashMap$Entry
Note there are no custom component been listed in DefaultCacheServer instance.
Thanks
sunder -
Running JRA recording with Weblogic running as a service
Is it possible to run JRA recording while running the WebLogic application server as a service?
The spec for our environment is as follows:
- JRockit JVM version: JRRT 3.1.0 1.4.2
- Weblogic version: 8.1 SP6
- OS: Windows XP SP3
Ideally, we would like to be able to run JRA recording every hour as an automated process, however as there is no java.exe process to attach to it seems this might not be a possibility? I appreciate is certainly possible to run the application as a console application and attach to the PID of a running java process using JRCMD if WebLogic is not running as a service. Are there any solutions for taking JRA recordings when JRockit is running in a Weblogic Service?Tim,
You can try to run beasvc.exe in debug mode, from a command prompt after the
server is booted. You can run it by: >beasvc -debug ...
This will simulate the service being started in the foreground so that you can
see output messages. You may be trying to run beasvc in a way that is not
intended. If you continue to have issues, you should open a case with BEA
Support.
Regards,
Glenn
Developer Relations Engineer
BEA Support
Tim Isenhart wrote:
I want to collect performance data from weblogic running as a service. I
customized the commandline in the installSvc script and inserted a profiler
class in front of weblogic.Server.
When i start the service, beasvc crashes.
How can i work around this without resorting to running a manual script ?
Thx,
Tim
Maybe you are looking for
-
What Is, And Why do I need it: ExpressCard/34 Slot?
In the very near future I will be obtaining a 17" MBP. That's just savvy, except for one minor detail. What is an ExpressCard/34 slot, why do I need one, why would it have been included in this particular size MBP and what can I shove in there?
-
Problems with Apache Plugin and IE
Hi, we are currently migrating from NES 3.6 to Apache 1.3.27. Since we use Apache 1.3.27 we encountered frequent crashes (Dr. Watsons) in IE 5.0. We can avoid this using an updated jsproxy.dll (of IE5.5 SP2 or later). However we cannot force our cust
-
Query-Select Item Code ending in 'NI'
How do I select an Item Code ending in 'NI'?
-
Hi, I have a custom page which invokes a custom supervisor hierarchy workflow which has got many approvals.The number of approvals will change based on certain conditions. Everything is fine so far but i am unable to figure out a logic to display the
-
While trying to launch a custom Developed Abap WD application from Portal EP7, a greyish screen appears before launching the application? Any clue?