Use the eclipse launcher, and set a breakpoint at an appropriate place in the main method.

Then, start in debug mode, enable profiling in visualVM, and then resume using eclipse.

That won&#39;t profile class loading and stuff, but it&#39;s good enough for me.




Are you setting up the profiling using the `-Xrunjdwp&quot; command-line option? If so, that option has a [&quot;suspend&quot; parameter][1] for just this purpose:

&gt;True if the target VM is to be suspended immediately before the main class is loaded; false otherwise.

Example from my own config:

    -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n

I use this with the YourKit profiler, but I think the principle is the same.

  [1]: http://download.oracle.com/javase/6/docs/technotes/guides/jpda/conninv.html#Connectors

I found [Startup Profiler][1] helpful:&lt;BR&gt;

&gt; Startup Profiler plugin for VisualVM 1.3.6 enables instrumented
&gt; profiling of local Java 5+ applications from their startup. It is also
&gt; helpful when profiling short-running processes.


  [1]: https://visualvm.github.io/startupprofiler.html

Both common Java development environments (NetBeans/Eclipse) support application execution directly with attached VisualVM. In case of Eclipse you have to install a [plugin][1]. In case of NetBeans the support is AFAIK already integrated.  
Even if do not have the sources you can still run the JAR file(s) via both environments and therefore start your app connected with VisualVM.


  [1]: https://visualvm.dev.java.net/eclipse-launcher.html

I am working on an embedded system running Linux on a DSP. Now we want to make some parts of it scriptable and we are looking for a nice embeddable scripting language. These scripts should integrate nicely with our existing C++ code base, be small and fast.

I understand that Lua is the industry choice for problems like this. We will probably go with Lua because it is tried-and-true and proven to be stable and so on. However, as a programming language it has some rather quirky corners.

So, what alternatives are out there for embeddable languages?

__EDIT:__

This is about a year later.  

We actually used Lua on our embedded system and it performs marvelously well. Over time, we added more and more scripting support to more and more parts of the project and that really helped to bring it along.  

Performance is outstanding, really. Even rather complex operations that involve searching through long arrays or fancy string operations perform surprisingly well. We basically never ran into Lua related performance problems at all.

Interfacing with C functions is very straightforward and works really well. This allowed us to grow the scripting system painlessly.

Finally, we were astounded at how flexible Lua proved to be. Our Lua interpreter has to run on a system with a nonstandard memory allocator and without support for the double data type. There are two well-documented places in one header file we had to modify to make Lua work on that system. It is really well suited for embedding!

Alternatives to Lua as an embedded language?

What&#39;s the difference between `x:Key` and `x:Name` in WPF?

I am not sure what the true difference is.

What&#39;s the difference between x:Key and x:Name in WPF?

As far as i can tell, [you can only profile a running application using VisualVM][1].

Does anyone know of a way to profile the launch and startup of a java application using VisualVM?

I&#39;m convinced there must be a way, otherwise it would be a major oversight.

Hoping I&#39;ve just misread the documentation.

Thanks, p.

  [1]: http://download.oracle.com/javase/6/docs/technotes/guides/visualvm/applications_local.html

how to profile application startup with visualvm

As far as i can tell, <a href="http://download.oracle.com/javase/6/docs/technotes/guides/visualvm/applications_local.html" target="_blank" rel="noopener noreferrer">you can only profile a running application using VisualVM</a>.
Does anyone know of a way to profile the launch and startup of a java application using VisualVM?
I'm convinced there must be a way, otherwise it would be a major oversight.
Hoping I've just misread the documentation.
Thanks, p.

A JVM runs in a single process and threads in a JVM share the heap belonging to that process. Then how does JVM make use of multiple cores which provide multiple OS threads for high concurrency?


How does Java makes use of multiple cores?

How to create a sub-array from another array? Is there a method that takes the indexes from the first array such as:

    methodName(object array, int start, int end)

I don&#39;t want to go over making loops and making my program suffer.

I keep getting error:

&gt; cannot find symbol method copyOfRange(int[],int,int)

This is my code:

    import java.util.*;

    public class testing 
    {
        public static void main(String [] arg) 
        {	
            int[] src = new int[] {1, 2, 3, 4, 5}; 
            int b1[] = Arrays.copyOfRange(src, 0, 2);
        }
    }


How to create a sub array from another array in Java?

I am working with a rather large app written in **JSF 1.2**.
JSF 1.2 is around 6 years old now. I need to upgrade to JSF 2.0. How painful will this be? I noticed that some attributes in custom tags have been changed etc. 

Migrating from JSF 1.2 to JSF 2.0

I [recently learned][1] that Unicode is permitted within Java source code not only as Unicode characters (eg. `double π = Math.PI;` ) but also as escaped sequences (eg. `double \u03C0 = Math.PI;` ).

The first variant makes sense to me - it allows programmers to name variables and methods in an international language of their choice. However, I don&#39;t see any practical application of the second approach.

Here are a few pieces of code to illustrate usage, tested with Java SE 6 and NetBeans 6.9.1:

This code will print out 3.141592653589793

    public static void main(String[] args) {
    	double π = Math.PI;
    	System.out.println(\u03C0);
    }

Explanation: π and \u03C0 are the same Unicode character

This code will not print out anything

    public static void main(String[] args) {
    	double π = Math.PI; /\u002A
    	System.out.println(π);

    	/* a comment */
    }

Explanation: The code above actually encodes:

    public static void main(String[] args) {
    	double π = Math.PI; /*
    	System.out.println(π);

    	/* a comment */
    }

Which comments out the print satement.

Just from my examples, I notice a number of potential problems with this language feature.

First, a bad programmer could use it to secretly comment out bits of code, or create multiple ways of identifying the same variable. Perhaps there are other horrible things that can be done that I haven&#39;t thought of.

Second, there seems to be a lack of support among IDEs. Neither NetBeans nor Eclipse provided the correct code highlighting for the examples. In fact, NetBeans even marked a syntax error (though compilation was not a problem).

Finally, this feature is poorly documented and not commonly accepted. Why would a programmer use something in his code that other programmers will not be able to recognize and understand? In fact, I couldn&#39;t even find something about this on the [Hidden Java Features question][2].

My question is this:

Why does Java allow escaped Unicode sequences to be used within syntax?
What are some &quot;pros&quot; of this feature that have allowed it to stay a part Java, despite its many &quot;cons&quot;?


  [1]: http://en.wikibooks.org/wiki/Java_Programming/Syntax/Unicode_Source
  [2]: https://stackoverflow.com/questions/15496/hidden-features-of-java

Why does Java permit escaped unicode characters in the source code?

Apostrophe doesn&#39;t get translated properly when placed in a resource bundle.

    key = {0}&#39;s brush is {1} centimeters tall

    (e.g. Sam&#39;s brush is 4 centimeters tall)

The apostrophe gets missed if I format the above key from a `java.util.ResourceBundle` What could be the problem here?

Apostrophe doesn&#39;t get translated properly when placed in a resource bundle

Need suggestion on tools similar to kcachegrind wingrind valgrind for mac platform. 

I don&#39;t think these work on mac, I already checked these.

Need kcachegrind like profiling tools for mac

It&#39;s really a simple problem : 

I&#39;m programming a Go program. Should I represent the board with a `QVector&lt;int&gt;` or a `QVector&lt;Player&gt;` where

    enum Player
    {
        EMPTY = 0,
        BLACK = 1,
        WHITE = 2
    };

I guess that of course, using Player instead of integers will be slower. But I wonder how much more, because I believe that using `enum` is better coding.

I&#39;ve done a few tests regarding assigning and comparing Players (as opposed to `int`)

    QVector&lt;int&gt; vec;
    vec.resize(10000000);
    int size = vec.size();


    for(int i =0; i&lt;size; ++i)
    {
        vec[i] = 0;
    }


    for(int i =0; i&lt;size; ++i)
    {
        bool b = (vec[i] == 1);
    }


    QVector&lt;Player&gt; vec2;
    vec2.resize(10000000);
    int size = vec2.size();


    for(int i =0; i&lt;size; ++i)
    {
        vec2[i] = EMPTY;
    }


    for(int i =0; i&lt;size; ++i)
    {
        bool b = (vec2[i] == BLACK);
    }

Basically, it&#39;s only 10% slower. Is there anything else I should know before continuing?

Thanks!

Edit : The 10% difference is not a figment of my imagination, it seems to be specific to Qt and QVector. When I use std::vector, the speed is the same

Are C++ enums slower to use than integers?

My Bash shell takes up to 3-4 seconds to start up, while if I start it with `--norc` it runs immediately.

I started &quot;profiling&quot; `/etc/bash.bashrc` and `~/.bashrc` by manually inserting `return` statements and seeking for speed improvements, but it is not a quantitative process and it is not efficient.

How can I profile my Bash scripts, and see which commands take the most time to execute?







How can I profile a Bash shell script slow startup?

I ran ruby-profiler on one of my programs. I&#39;m trying to figure out what each fields mean. I&#39;m guessing everything is CPU time (and not wall clock time), which is fantastic. I want to understand what the &quot;---&quot; stands for. Is there some sort of stack information in there. What does calls a/b mean?

    Thread ID: 81980260
    Total Time: 0.28
    
      %total   %self     total      self      wait     child            calls   Name
    --------------------------------------------------------------------------------
                          0.28      0.00      0.00      0.28              5/6     FrameParser#receive_data
     100.00%   0.00%      0.28      0.00      0.00      0.28                6     FrameParser#read_frames
                          0.28      0.00      0.00      0.28              4/4     ChatServerClient#receive_frame
                          0.00      0.00      0.00      0.00             5/47     Fixnum#+
                          0.00      0.00      0.00      0.00              1/2     DebugServer#receive_frame
                          0.00      0.00      0.00      0.00            10/29     String#[]
                          0.00      0.00      0.00      0.00            10/21     &lt;Class::Range&gt;#allocate
                          0.00      0.00      0.00      0.00            10/71     String#index
    --------------------------------------------------------------------------------
     100.00%   0.00%      0.28      0.00      0.00      0.28                5     FrameParser#receive_data
                          0.28      0.00      0.00      0.28              5/6     FrameParser#read_frames
                          0.00      0.00      0.00      0.00             5/16     ActiveSupport::CoreExtensions::String::OutputSafety#add_with_safety
    --------------------------------------------------------------------------------
                          0.28      0.00      0.00      0.28              4/4     FrameParser#read_frames
     100.00%   0.00%      0.28      0.00      0.00      0.28                4     ChatServerClient#receive_frame
                          0.28      0.00      0.00      0.28              4/6     &lt;Class::Lal&gt;#safe_call
    --------------------------------------------------------------------------------
                          0.00      0.00      0.00      0.00              1/6     &lt;Class::Lal&gt;#safe_call
                          0.00      0.00      0.00      0.00              1/6     DebugServer#receive_frame
                          0.28      0.00      0.00      0.28              4/6     ChatServerClient#receive_frame
     100.00%   0.00%      0.28      0.00      0.00      0.28                6     &lt;Class::Lal&gt;#safe_call
                          0.21      0.00      0.00      0.21              2/4     ChatUserFunction#register
                          0.06      0.00      0.00      0.06              2/2     ChatUserFunction#packet
                          0.01      0.00      0.00      0.01            4/130     Class#new
                          0.00      0.00      0.00      0.00              1/1     DebugServer#profile_stop
                          0.00      0.00      0.00      0.00             1/33     String#==
                          0.00      0.00      0.00      0.00              1/6     &lt;Class::Lal&gt;#safe_call
                          0.00      0.00      0.00      0.00              5/5     JSON#parse
                          0.00      0.00      0.00      0.00              5/8     &lt;Class::Log&gt;#log
                          0.00      0.00      0.00      0.00              5/5     String#strip!
    --------------------------------------------------------------------------------



Understanding ruby-prof output

The standard way to profile an Android application in Eclipse is using the plugin DDMS and creating a trace file with all the information inside. If you want to view this information you can use &quot;traceview&quot;. I didn&#39;t like my first experience with this application because you can&#39;t filter the results. You have a lot of method calls for starting your application and you cannot filter only your code.

I have been looking for an alternative method. I found this tutorial [Using Eclipse* TPTP to Visualize Google* Android* Profiling Data][1] that explains how you can use the Eclipse Test &amp; Performance Tools Platform (TPTP) Profiling tool to visualize Android profiling data. Thanks to this previous post [Permission to write to the SD card][2] I managed to take my trace file from the Android Emulator into my file systems. The next step is converting this .trace file into a TPTP .trcxml file. I didn&#39;t find this converter they talk about.

Anyone knows where I can find this converter? Do you know another way to analyze this trace file with TPTP or with another more mature FREE profiler tool? Do you know another way to profile Android application? Thanks in advance


----------

**Edit 1**:

I found some interesting tool you can use to analyze Android apps memory usage. In order to get memory usage from Eclipse you have to &quot;Dump HPROF file&quot; from the DDMS prospective. Before doing that you have to choose in the DDMS preference panel, when it says &quot;HPROF Action&quot;, the &quot;Save to disk&quot; action. So from now on when you dump HPROF file you&#39;ll be asked where you want to save your .hprof file. You have to convert this file with the Android tool &quot;hprof-conv&quot; you can find in your Android SDK installation under the directory &quot;./tools&quot;. Finally now you can use the [Eclipse MAT][3] plugin to view the memory usage stats. I hope it will help someone else. If anyone knows something else about profiling Android apps it will appreciated. Thanks


  [1]: http://www.eclipse.org/tptp/home/documents/conferences/eclipseCon2009/383_AndroidTPTP.pdf
  [2]: https://stackoverflow.com/questions/2121833/permission-to-write-to-the-sd-card
  [3]: http://www.eclipse.org/mat/

Profiling Android apps with Eclipse plugin TPTP instead of traceview

I&#39;m using VisualVM from JDK 1.6.0_26 to profile a Java webapp running under Tomcat, but VisualVM often tells me that it doesn&#39;t have enough memory to take a snapshot, and to use the -Xmx switch to provide more memory to Netbeans. The problem is, I&#39;m running VisualVM outside of Netbeans, so how can I provide JVM arguments to jvisualvm.exe?

How do I provide JVM arguments to VisualVM?

I&#39;ve been searching all over for a consistent and clear explanation of what &#39;self time&#39; actually refers to in the VisualVM context and how does it differ to &#39;self time (cpu)&#39;. Also does &#39;self time [%]&#39; refer to self time or self time cpu. 

There doesn&#39;t appear to be much documentation on this or at least I haven&#39;t found it. So any thoughts/input will be appreciated.

VisualVM and Self Time

Other than the more &#39;advanced&#39; GUI from Java mission control, how are they different?

At first glance they seem to offer very similar functionality (Interpreting JMX data and Memory/CPU profiling).

However, as they are both shipped with the JDK (I&#39;m using JDK 1.7.0_51 SE) I&#39;m assuming there are significant differences, otherwise they would be combined into a single solution. Especially as this increases the size of the JDK significantly.

Is Java Mission Control ultimately going to replace JVisualVM in the future?

What are the differences between JVisualVM and Java Mission Control?

If I try to profile application, (which is prepared under Eclipse, but running from command line) with the help of VisualVM, I get the following error message

![enter image description here][1]

Simultaneously, the project folder is fouled with newly created class files. Although they are already existing in `target/classes`.

The project structure is Maven&#39;s, i.e. there is a foder `target/classes` in current directory and I us the following command to run the application

    java -Xmx16g -cp target/classes tests.Runner01

How to fix?

**UPDATE** 

The same occurs with conventional java project too.

Below it the picture of populated class files, which located where they should not 

![enter image description here][2]




  [1]: http://i.stack.imgur.com/GPhyQ.png
  [2]: http://i.stack.imgur.com/zuetp.png

Redefinition failed with error 62 while trying to profile an application

Can someone please explain me the difference between `Sleeping`, `Wait`, `Park`, and `Monitor` thread states in VisualVM.

![enter image description here][1]

This is what I have found:

`Running`: thread is still running. &lt;br /&gt;
`Sleeping`: thread is sleeping (method yield() was called on the thread object)&lt;br /&gt;
`Wait`: thread was blocked by a mutex or a barrier, and is waiting for another thread to release the lock&lt;br /&gt;
`Park`: parked threads are suspended until they are given a permit. Unparking a thread is usually done by calling method unpark() on the thread object&lt;br /&gt;
`Monitor`: threads are waiting on a condition to become true to resume execution

What I am unable to understand is the state Park, what actually suspends the thread? How do I detect in the code what has made the thread suspend its execution?

Can someone please guide me in this regard.

Thanks.


  [1]: http://i.stack.imgur.com/4WYvV.png

Content Type	Original Author	Original Content on Stackoverflow
Question	pstanton	View Question on Stackoverflow
Solution 1 - Java	KarlP	View Answer on Stackoverflow
Solution 2 - Java	skaffman	View Answer on Stackoverflow
Solution 3 - Java	Haim Raman	View Answer on Stackoverflow
Solution 4 - Java	Robert	View Answer on Stackoverflow

how to profile application startup with visualvm

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Solution 4 - Java

What's the difference between x:Key and x:Name in WPF?

Alternatives to Lua as an embedded language?

Attributions