Slashdot Mirror
Java Profilers - Which One Are You Using?
splitPersonality asks: "Our Java programmers are researching various profilers to use in-house. We would appreciate some feedback from other shops that are using Java profilers. Along with the specific product, would you please include reasons behind your choice? If you now have misgivings about the one you or your shop chose, please let me know about those, as well."
The netbeans one, whatever it's called.
It let me know exactly how long it took for new GUI windows to be created.
I've used JProfiler quite a bit. We picked it because it was reasonably priced and reasonably well featured. It is offered by a fairly small company and I've found the support to be pretty good.
YourKit is extremely easy to use thanks to a very intuitive interface.. All the java developers I've shown it to have been as impressed as I've been. It is cheaper than most profilers -- I got a deal on it for $125 a few months ago, which I is about 25% of the normal price, but it's still cheap at $499. It's not open-source, but they have a forum where they answer they questions extremely quickly. I've had 1 or 2 bugs since I've been using it (about 10 months), since I like to use the early release version for newer features, and both have been fixed within days, with a new build released within a week or so. Memory leaks are a snap to find using it's "compare snapshot", which lets you compare 2 snapshots and shows you what the difference is -- memory leak is generally the difference if you capture your snapshots intelligently.
Anyway, I can't speak highly enough of the product. For the record, I have no affiliation with them at all. I'm just a very happy customer.
My only minor gripe is that under some circumstances, the fastest CPU profiling option (unnoticeable impact on the running app) can give inaccurate results, in which case I have to use one of the two slower CPU profiling options, which are much, much slower--but that's certainly not particular to YourKit.
Java's available sets of tools for this kind of stuff is woefully inadequate, but here's what I use: NetBeans Profiler: Not bad for what it does, Memory Stack Allocation tracers are nice, but I haven't been able to get it to profile just certain methods in a selected class. It also seems pretty stable over long periods of time and doesn't interfere too much with the running of the application. JMP: I started using this for it's heapwalking abilities. Other things I've tried are hprof and hat... but with no success at all. JMP is not stable over long periods of time. It will frequently just decide to take a vacation even if you aren't monitoring anything, but for tracking down things like object owner chains, it's very good. Haven't done any actual performance profiling, so that's the extent of my knowledge.
I use several tools depending on the application.
For step-through-your-code debugging nothing beats Jprobe, although perhaps a fellow slashdotter
can suggest a public domain equivalent
If you want to profile your code in a "production" situation, i.e. you need minimal overhead
while instrumenting methods to understand where in your stack trace time is being spent
you have two options. Mercury Interactive sells a product that instruments all methods,
aggregates method usage and gives you a "top talker" summary. Wyle Introscope on the other
hand instruments only the methods you want, but can drill down into things like JDBC and capture
executed SQL. Their product Leakhunter can help you find memory leaks, but creates too much drag for prod usage.
Finally if want something that combines elements of Mercury's inclusive approach of instrumenting
everything and top talker summaries and with Wyles approach of watching for heap usage, GCs and so
on you want a copy of YourKit. I own all the products mentioned but have to say YourKit is my current favorite.
Although I've not had call to use one for a few years, I've liked OptimizeIt for a long time - they were bought by Borland but I think you can still buy the software on its own.
JProbe also seemed pretty good...
I also had good luck with HAT (heap allocataion tool, built into Java) if you are just looking for memory leaks. The HProf stuff also works and again is built in.
---> Kendall
"There is more worth loving than we have strength to love." - Brian Jay Stanley
Hello? Profilers. As in: not debuggers.
Just write everything in Ruby; you won't need a profiler then because it is dog slow no matter what.
JRat is open-source, and works anywhere using bytecode injection. It's the only serious solution for profiling applications running in production as it
:) Enjoy.
A) doesn't require much overhead
B) doesn't require code changes
C) doesn't require some sort of front-end to monitor or use
D) doesn't have a rediculous cost per server
E) runs in your typical environment, not some magical profiling IDE option
We use this every day (via an ant task) to profile a Wall Street trading system that handles billions of dollars of transactions every week. Would you trust that to anything else?
Signing anon because my employment contract specifically prevents me from revealing this sort of thing
The tools that come with Java, while not at all user-friendly, have always been enough to point us in the right direction. We've never really come across a situation where we couldn't find the problem or optimize the code once the right track has been pointed out. YMMV.
It's simple: I demand prosecution for torture.
We bought a few JProfiler licenses a few years ago and have had good success with it. It can easily profile remote JVMs (servlet containers, for instance). I've used the Heap Walker a few times to discover static references that shouldn't be kept around and have had good success finding performance bottlenecks.
I hear recent versions plus 1.5 resolve a lot of stability and performance problems, but I haven't had enough problems to warrant pulling it out in a while. It's not a perfect product, but it's told us what we need to know.
Ceci n'est pas une signature.
Believe it or not, I do most of my profiling by running by using:
r ead=y'
alias java-prof='java -agentlib:hprof=cpu=samples,depth=8,interval=1,th
And then I view the results with PerfAnal.jar (google will find it for you), an extremely old (and even ugly) GUI that is also clean and mean. It's also free (beer? not sure.)
I've tried a number of other profilers (JFluid, YAJP, etc.), and they usually prove to be too much of a pain in the ass, or just give nonsense data.
Mind you, I'm usually interested in pure CPU performance-- tightening inner loops and things like that. I don't care too much about memory profiling or garbage collector behavior since I've long since eliminated most allocations in my performance-sensitive code.
Sadly, no profiler really satisfy me. Usually, line-by-line CPU usage just can't be computed given the optimization performed by HotSpot: you'll see trace-by-trace CPU usage, where a trace covers several lines of code. It makes it hard to know exactly where the CPU time is being spent. (You can run with -Xint, but the performance is so different without HotSpot that it's not helpful.)
Have you ever actually worked at a company in your life?
If I invented something tonight which was faster than whatever you were using today, and yet you were running into memory leaks that required restarting or rebooting servers you run 24/7, and losing thousands of dollars by the minute, but were within reach of serving your current load if you could identify the leaks, would you turn off your servers until you finished rewriting your application in my language?
He's not asking about 'performance', hes asking about how to chase memory leaks via a profiler. He's not concerned about performance, hes concerned about RAM usage due to memory leaks due to programming bugs. Please tell me people like you are not actually employed as programmers or programming project leads. You're advise is as useful as the lowest of the low tech support, "Oh, thats your problem? Well, you should just probably quit everything you're doing, and re-invest from the ground up in some other product or technology."
Its useless advice because thats not the question being asked. And just like low tech support, he probably knows more about the alternatives than you do.
"Old man yells at systemd"
We use DevPartner which seems to work pretty well for me. It's fairly neat the way it works. Although it does seem to identify some things as memory leaks that probably aren't actually leaks (ResultSets, IBM MQ Series objects, etc), if you limit the check to your own packages, a lot of your in-house errors will stand out right way and it will ignore the (assumed) false spots. Give it a try.
I've used the Eclipse Test & Performance Tools Platform with pretty good results:
i ling-Tool/tptpProfilingArticle.html
http://www.eclipse.org/articles/Article-TPTP-Prof
My Web Page
Read his question again. Here, I'll even quote it for you:
splitPersonality asks: "Our Java programmers are researching various profilers to use in-house. We would appreciate some feedback from other shops that are using Java profilers. Along with the specific product, would you please include reasons behind your choice? If you now have misgivings about the one you or your shop chose, please let me know about those, as well."
Do you see any reference to "memory", "memory leaks", "RAM consumption", and so forth? No, you do not. Because that's clearly not what he's asking about.
Unless specifically qualified as "memory profiling", the term profiling is meant to refer to measuring the time spent in certain pieces of code. Anyone who has any experience, be it industrial, academic or hobbyist, knows that simple fact.
If he (or his superiors) actually did know more about the alternatives, then they wouldn't be asking about what Java profiler is best. Why is that? Because they wouldn't be using Java! They'd be using Python, Ruby, C++, or any number of other languages that offer better performance, and far better memory usage.
And it's best if you avoid ad hominem attacks while debating. It's very poor style, in case you weren't aware. We're trying to have a serious discussion here about this fellow's software development predicament, and you keep bringing up personal insults. Please, for the sake of helping this individual, refrain from such childish behavior in the future.
I had good results with JProfiler when tracking down some memory leaks in our Java app. Found out we were hanging on to some references much longer than we should have. JProfiler lets you snapshot counts of objects (after GC), do this again after a 'test run', and then find the offending objects. You can then locate where they were allocated, who is still holding on to them and so forth. Neat.
dominionrd.blogspot.com - Restaurants on
A stopwatch.
I have used JMeter a couple of times to detect bottlenecks and synchronization problems with web apps. Very simple to set up and run just using a GUI. Apart from http/https it can appearently call java methods, EJBs etc too, but I haven't tried that. I think this tool is easier to use for stress testing rather than going through a whole use case. Also, when running against a web server of course it just tells you that something is slow, not what.
:-)
At Java One I talked to some fellow Swedes who were a bit disappointed with JProbe, they claimed it was a bit of a resource hog and that they had found a better more light weight open source library to use instead. I've looked through my notes, but it seems I didn't write down the name of the one they recommended. Darn.
Symantec had an app that seemed pretty impressive, though I don't know how much they charge for it. I think it was this one. I remember them because unlike most who just had a lottery for prizes, you actually had to run the demo to be able to answer their quiz. Pretty clever, made people remember and gave you a better chance of winning because most people wouldn't bother. I won a PSP.
Also at Java One this year Sun had loads of labs and talks on profiling tools and frameworks that come with the JDK itself these days - JMX (especially in combination with DTrace if you run on Solaris), jconsole, jmap, jhat.
And then of course there is this whole site...
Being bitter is drinking poison and hoping someone else will die
it's actually very easy to get excellent performance out of java -- just use data structures as you would use them in C:
i'm currently using java to do classical molecular dynamics simulation (and statistical analyses thereof: esra), and the speed (without any tweaking) is consistenly within a factor of two of what i would get with C/C++. this is certainly not so with python (which, for my numerical problems, turned out to be about four orders of magnitude slower).
YMMW, but mine is excellent ... no more segfaults, dead-simple deployment, scriptability, eclipse
etc.
check your speling
Interesting to see this question come up just a week after I was in deperate need of a profiler. I downloaded JProfiler 4.2 and got a test-license (for 10 days or so). (oh, and I work on a Mac, and it has downloads for 3 platforms).
The problem I had was the following. We upgraded our system from the previous stable release of our opensource CMS to the new stable release. We knew a lot had changed in the internals, so we did a good functional testround and fixed quite a few issues. Quite confident in the new software (it appeared faster) we deployed on our live environment. Looked fine, until after a few hours it didn't stop Full-GC-ing, the symptoms of a memory leak. (and yes, I know how to tune my VM to optimum GC performance).
All I can say about JProfiler is that after only 3 or 4 days, I found all memory leaks, several performance issues (even things like 'for (int i=0; istr.length(); i++)'), and got a real good feel about the bottlenecks inside the application. My manager just bought me a $400 or so license, and it's money very well spent.
So next week we'll go live again, but now with a piece of software of which we exactly know how it behaves.
I suggest you download the evaluation version and just give it a try. I can't imagine putting a release live anymore, without having profiled it for at least a day.
--
If code was hard to write, it should be hard to read
Often times it doesn't matter how much you profile your Java application. The bottleneck will often be hidden away, deep in some class library that either you can't modify (due to licensing restrictions or unavailable source code), or that you don't want to modify.
And that bit of information about your app is worth nothing to you? No wonder your java apps are slow.
sudo ergo sum
Arrgh! I can't stand it when people refer to a company as a "shop" (especially when used to refer to software develeopment companies)! Really, it just sounds utterly stupid, like corporate trying so hard to be cool. I hear it all the time "oh, we we're a Java shop", "yeah, I hear they are an all Linux shop". It's irritating, unnessecary, not very descriptive and just plain stupid. Cut it out people!
We tried YourKit evaluation (30days) and was very pleased with the software. Sadly the license fee's are too high for my company, and it only gets you updates for one year. But I'd be interested to hear where the 75% discount version is available from???
I think they also do a free licence for open source projects which other readers might find useful.
From my experience of this tool it does everything you need. The integration with eclipse is simple, and remote profiling is really nice. For a large system the dumps can be quite large, maybe they could use a more compressed format, but then the application we are profiling has a max heap of 3GB so I guess we should expect some large files.
The accuracy of the simple timing option wasn't the best, but the more detailed profiling seemed to give fairly consistent results. The GUI is very nice to use with lots of help and tips. It's also very responsive and you can quickly drill down through your code to find where the time is being spent.
Summary: If you have a memory leak or performance problem in Java, this tool will find it. Could be cheaper!
Ruby actually comes with a built-in profiler (likewise for Python). The point? As for any profiler, discovering the bottlenecks of your applications to either change your algorithm (since you create the same functionality in 1/10ths of the time you have the time to refine your algorithms) or recode the bottleneck (and the bottleneck only) in a lower-level language (C or C++)
"The way we can tell it's C# instead of Haskell is because it's nine lines instead of two." -- wadler
I definitely recommend JProfiler - I've used it for a couple of years now and it has always been easy to use and very effective at giving me the information I need.
Hope that helps.
For somebody with such a low UID, you're really bad at not feeding trolls.
Do you really find a performance difference with 'final' ?
I'd be interested to hear your experiences here. I advocate 'final' as an aid to expressiveness, but understood the performance benefits were minimal these days.
In a word no. (Except for aggresive inlining of code but I have not measured on that).
"final" allow you to state information _in code_ about what you are doing about invariants, and letting the compiler enforce this.
This allows the designer and maintainer to catch accidential assignments too. Not a bad thing.
--
Thorbjørn Ravn Andersen "...and...Tubular Bells!"
I like JProbe. It's a little cumbersome to setup, but has great analysis tools with graphical call trees, call stack drill-down, etc. What I like the best is the ability to prune the results interactively to isolate the piece of code you are interested in.
"No matter where you go, there you are." -- Buckaroo Banzai
It also works in concert with other performance tools from Symantec for other tiers in the enterprise, database tools, network tools, web server tools, web client tools. Then the tool suite combines all this 'tier level' information into an enterprise view and gives you a view of performance of the entire data center so you can determine which tier in the enterprise is the performance hog.
JFluid (a.k.a the NetBeans Profiler)
1. Free
2. Trivial to configure/run (as easy as debugging in NB)
3. You can specify a subset of the app to profile, and the rest of the app runs at full speed (profilers like JProbe force you to slow down the whole VM). This also makes the output much more readable, since you're not seeing all kinds of statistics from code you're not interested in.
4. Attach/detach to a running application, which requires no special cmd line options when launching.
5. Analysis tools are good at finding memory leaks, based on discerning patterns in allocation/deallocation
Check it out at http://profiler.netbeans.org/
-----
Kvetch is Yiddish for "throw an exception" --Dr. Ron Cytron
In Soviet Amerika the NSA profiles you!
- Lightweight -- JIP is an exteremly fast profiler.
- Interactive
- Open Source
- 100% Java
While JIP can't complete with many commercial tools in terms of total functionality, it's simple and in most cases that's enough. Organization that can't pay for a commercial tool should certainly give it a try.Having said that though, I did see one case recently where it made a big difference. On a Lisp newsgroup that I read, somebody implemented a cellular automaton algorithm in Lisp and Java for comparison, and he had a reference to non-final local variables (for no good reason) from within some gnarly nested loops (See here, especially message #2), and making just the top 4 local variables final (the ones used in the nested loops) yielded a large improvement (measured at around 7% using client vm, not sure about server vm because other changes were mixed into that measurement, but probably more considering its more extensive optimizations). Anytime not making the variable final will prevent the server vm from being able to inline the variable inside a bottleneck loop, it will make a huge difference, but it doesn't happen that often.
Oracle's JDBC drivers are complete crap, but that was bad even for Oracle.
The replies to this post has given my team a lot of food for thought. As usual, the slashdot community replied with a lot of intelligent feedback and added a dash of humor too.
I especially appreciated the discussions on features. Many had been on our wish list, but others had been overlooked.
Thanks Again!
"I don't suffer from insanity, I enjoy every minute of it." - author unknown
Dude, it's bAnzai not bOnzai --> http://www.imdb.com/title/tt0086856/ Gotta love that movie.. :) ..
I wasn't feeding the trolls, the trolls were feeding me. See moderation of my post.
"Old man yells at systemd"
I did not succeed to install eclipse plugins from TPTP (Tracing and Profiling Tools Platform) on my Mac. I think, but I'm not sure, that something is missing, something like platform specific software agents to run up the profiler on Mac. Then, I myself reminded a news about the release of the NetBeans Profiler for Mac OS X. http://profiler.netbeans.org/ What an experimental stuff! This is definitely the PROFILER for Java! (Cross my heart, I'm not working for Sun and I'm still using the eclipse IDE). I had to download and install NetBeans 5, an eclipse import module and switch to JDK 5. Bingo, just like that... and all is running fine on my PowerBook.
- didn't think static fields are GC roots (they aren't, they are reachable through classes, and classes are not GC roots, unless loaded by system classloader)
- recognized that classes keep a strong reference to their classloader
- recognized that array classes keep a strong reference to the classloader of their component type
and maybe few others.I've tried OptimizeIt, JProbe, HAT (I even submitted patches to it to recognize some of the above), Eclipsecolorer, and YourKit in the past, and found that YourKit is the best for me.
Sig erased via substitution of an identical one.
As a part of MacOSX dev tools, you get shark, which includes java profiling. What is nice about Shark is it is the tied to the kernel profiler as well, so you can switch from java to native profiling in a flash, with the same UI. Also, it includes a bunch of data mining features, such as filtering out small methods (profile time http://developer.apple.com/tools/sharkoptimize.htm l