Can You Trust Your JVM Diagnostic Tools?

Save this PDF as:
 WORD  PNG  TXT  JPG

Size: px
Start display at page:

Download "Can You Trust Your JVM Diagnostic Tools?"

Transcription

1 Can You Trust Your JVM Diagnostic Tools? Isaac Sjoblom, Tim S. Snyder, and Elena Machkasova Computer Science Discipline University of Minnesota Morris Morris, MN Abstract Programmers may use Java diagnostic tools to determine the efficiency of their programs, to find bottlenecks, to study program behavior, or for many other reasons. Some of the common diagnostic tools that we examined are profilers and the Java Virtual Machine (JVM) options that make some internal JVM information available to users. Information produced by these tools varies in degrees of clarity, accuracy, and usefulness. We also found that running some of these tools in conjunction with a program may affect the program s behavior, creating what we refer to as an observer effect. We examine several tools and discuss their level of usefulness and the extent to which they impact program behavior. Additionally, we discovered program instability, i.e. a tendency of a program to change its behavior when executed with different monitoring tools or multiple times with the same tool. We discuss potential causes for instability based on information obtained via running the HotSpot JVM with an option for logging its internal compilation and optimization process.

2 1 Introduction Java programming language is executed by an interpreter known as the Java Virtual Machine (JVM). Modern JVMs are equipped with sophisticated tools for dynamic program optimization that profile and optimize the program as it is being executed. In this complex setup, monitoring a program by trying to examine its run-time behavior becomes quite challenging. The reason for this is that the monitoring tool and the JVM that is running and optimizing the program all share the same resources (CPU, cache, etc). This may create an observer effect : the change in the program behavior when it is being executed together with a monitoring tool, whether embedded into the JVM itself or an external one. In this project we are interested in studying Java program behavior caused by a certain inheritance pattern related to generic types that we refer to as bound narrowing. Programs with bound narrowing that are very similar to each other exhibit different behavior in terms of their run time. While trying to explain the differences, we tried various Java diagnostics tools, both stand-alone (such as HPROF profiler) and those embedded into the HotSpot TM VM. In particular, we explored a log compilation option available in the HotSpot JVM. This option keeps a detailed log of optimizations performed at the run time. We present the observations about the accuracy and usefulness of the monitoring tools, using bound narrowing examples as a case study. We show that most of the programs are stable with respect to the monitoring tools considered in this paper, i.e. relative times in a group of programs remain the same regardless of the tools (although constant differences in times for the entire groups have been observed). However, some programs are unstable, i.e. their behavior patterns change depending on whether they run in the JVM under default conditions or with a monitoring tool. In fact, some programs behave differently when executed repeatedly in the JVM with the log compilation option. Since this option produces a detailed log of both successful optimizations and failed attempts, we were able to determine what causes the differences in behavior based on these logs. 2 Java Virtual Machine and Diagnostic Tools 2.1 Java Compilation Model Unlike statically compiled languages, in which a program is optimized and compiled into machine code in the same step, Java has a two-phase compilation model. First, the program is compiled by a static compiler, such as Javac, into bytecode for portability. Second, the bytecodes are executed on any system that has a Java execution environment, referred to as the Java Virtual Machine (JVM). The JVM that comes standard with the Java Development Kit (JDK) is called HotSpot TM VM. Most modern JVMs, including HotSpot, are equipped with a Just-in-time compiler (JIT) that performs optimizations as the program is being run and may convert a portion or all of a program s bytecode to native code on the fly. This process is called dynamic compilation. Two common examples of JIT optimizations are constant propagation and inlining. Constant propagation is when references to a constant in a program are replaced with the constant s value. Inlining is when the JIT replaces method calls with all of the method in- 1

3 structions. This removes the method call, and therefore method look up, and allows for further optimizations to take place. Inlining would be similar to copying a whole method and pasting over the call to that method. 2.2 HotSpot Server Just-In-Time (JIT) Compiler The HotSpot JVM features two modes, client and server that differ in their JIT compilers. The server mode provides more optimizations than the client mode and as a result may have faster run times than client for longer programs. However, the optimizations may be more time-consuming than those applied by the client mode [6]. The server mode is intended for server-side applications. Client mode is the default for HotSpot on 32-bit architecture. It provides faster application startup and requires less memory than server. It is intended for client-side Java programs, such as applets, and is currently not supported for 64-bit architecture [3]. In this paper we are only considering the server mode. HotSpot JVM provides multithreading support. Multithreading is the parallel execution of a program through various processes, effectively executed by the hardware but may be handled by the virtual machine. When handled by the hardware, the processes are divided between the systems processors. However, our system has one processor to limit variations during dynamic compilation as much as possible. A feature of this JVM is preemptive multithreading based on native threads; that is, that threads defined in a program are handled by the JVM and passed to the operating system for support. We observe that this extends to multithreading JIT compilation, that is, optimizations in JIT compilation may take place in different threads. 2.3 Profilers, HPROF A profiler is a piece of software that observes and interacts with a program to gather information about its execution, such as data on how often methods get called. HPROF is a specific profiler that can run in two different modes, sampling mode and method counting mode [2]. Sampling mode will run by finding out what the stack is like at certain time intervals to get an estimate for how often methods are being called and where they are on the stack most. Method counting mode, on the other hand, will count how often methods get called by putting in at least one line of code that creates a counter in the method that increments on each call. This approach is called bytecode injection. Method counting mode causes a drastic increase in run time due to an overhead of counting. In addition inlining is disabled because of bytecode injection. This is a type of observer effect : observing a program by means of a profiler changes its behavior [1]. 2.4 Internal JVM Diagnostics Internal JVM diagnostic tools were created by the JVM developers to provide themselves access to various internal JVM information. These tools were not developed for Java programmers, which may be the reason that the internal JVM diagnostic tools are somewhat under-documented and not guaranteed to work for every JVM distribution [5]. 2

4 HashMap::putAll (133 bytes) 15 NarrowedIS::put (13 bytes) 16 NarrowedIS::put (38 bytes) 1% 90 (133 bytes) 17 HashMap::entrySet0 (28 bytes) 18 HashMap$EntrySet::iterator (8 bytes) 19 HashMap::newEntryIterator (10 bytes) HashMap::putAll (133 bytes) 15 NarrowedIS::put (13 bytes) 16 NarrowedIS::put (38 bytes) 17 HashMap::entrySet0 (28 bytes) 18 HashMap$EntrySet::iterator (8 bytes) 19 HashMap::newEntryIterator (10 bytes)... Figure 1: Showing different results for print compilation for two runs of the same program (only a fragment shown). Two of the relevant diagnostic tools we were using are Print Compilation and Log Compilation. They are both flags provided by the JVM. On the command line the flags look like this [5]: -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation When the print compilation flag is turned on, a message is printed whenever JIT translates a method into machine code. This flag provides some information about the JIT behavior, but its output format does not have a clear publicly available documentation and the results can be confusing. An example of this is the field size of method in bytes where the number associated with this field is, as evidence suggests, a somewhat arbitrary number to approximate the size of the method but does not have a clear definition. A method is often compiled to native code more than once, with different byte sizes. An additional complication arises from the fact that output of print compilation differs for multiple runs of the same program, even if the runs take the same time, as demonstrated in Figure 1. In Figure 1 we show a partial print compilation output for two runs of the same program that resulted in the same running times. We see that between lines 16 and 17 of the output of the first run there is a reference to HashMap::putAll that does not appear in the second run s output. The log compilation flag turns on logging of the compilation process: when and in what order program code is translated into bytecode, optimized and translated into native code where applicable. It also records the information about threads of the JIT compiler and which tasks they perform. When the log compilation flag is turned on, a second flag, unlock 3

5 diagnostics, must also be turned on. The log is written as a large XML file recording every action of the JIT, with timestamps. This option produces accurate detailed information for analyzing program behavior. However, we have observed that using these flags leads to changes in the behavior of some programs, most likely due to recording information forced by unlocking the JVM diagnostics See section 5 for more details. 3 Effects of Bound Narrowing 3.1 Generic Types in Java Generic types are a feature of Java that allows writing program code that is parameterized over types. For example, generic types allow creation of a Stack class that that allows instances of Stack to be constructed with any object such as strings or integers, but will not allow mixing strings and integers in the same instance of Stack. In this case String or Integer class are referred to as type parameters for the generic Stack class. An example of generic types is the following class: public class HashMap<K, V> HashMap has two type parameters, a key type K and a value type V. An example of the instantiation of HashMap would be: HashMap<K,V> myhashmap = new HashMap<Integer,String>(); Here, we instantiate HashMap with an Integer for a key and a String for a value. This limits the instance of this class myhashmap to only be used with an Integer for a key and a String for a value. There can also be type bounds placed on generic types. A type bound is a class or interface that limits the generic parameters to that class or subtypes of that class or interface. public class ComparableHashMap<K extends Comparable, V extends Comparable> This ensures that the key and the value are of types that implement Comparable interface. Implementations of HashMap allow for construction of an instance involving any class for the key or the value. ComparableHashMap has a more strict implementation where the construction of an instance demands a Comparable or a subtype of Comparable for the key and value. Generic types may be subtypes of other generic types. Commonly the type bound of a subtype is the same as the type bound of its supertype. However, Java allows for the subtype to have a more restrictive bound than its supertype; also, a non-generic class may inherit from a generic class or interface by hard-wiring a specific type for a type parameter. We refer to these inheritance patterns as bound narrowing. An example of bound narrowing where a non-generic class is inheriting from a generic class is the following: public class NarrowedHashMap extends HashMap <Integer, String> 4

6 Here, NarrowedHashMap inherits from the class HashMap where the key and value are specifically Integer and String, respectively. 3.2 Delays Associated with Bound Narrowing In our previous research, we found that bound narrowing causes substantial runtime inefficiencies when the JIT is disabled. When bound narrowing is present, the system has to verify that objects passed to a method of a more specific (narrowed) container by a call to a method of its more general supertype are of the correct type. When the JIT is not allowed to perform the necessary optimizations such as inlining, described above, these type checks have to be performed every time an object is placed into a container. We have found that some of these delays will go away in runs under default HotSpot JVM conditions (with the JIT optimizations on) while others remain. In the current research, we are continuing to study bound narrowing, specifically when the delays remain and why [7]. 3.3 Test Cases The code that we have been testing is based on the HashMap class in the Java collections library. We chose this code base because of a specific class called PrinterStateReasons that is a part of the javax package. The reason that PrinterStateReasons is important to us is because it is a narrowed version of the generic HashMap and is a real-life example of bound narrowing. Below, we are showing only relevant fragments of code. public final class PrinterStateReasons extends HashMap<PrinterStateReason, Severity> The bound here is on the way down from HashMap because the PrinterStateReasons class has a more specific bound than the generic HashMap. PrinterStateReason is a class that provides information about a printer s current state while Severity provides information on how severe that state is. Our version of this code uses Integer and String instead since PrinterStateReason and Severity have a limited number of instances. Our test code accesses the class being tested via an interface, Map, with a key and a value both bounded to Object. We have a class, HashMap, that implements this interface that is still completely generic. These classes are copies of the standard Java collection packages and PrinterStateReasons with our own methods added as needed. public class HashMap<K,V> extends Map <K, V> Our test classes, which are the four subclasses in the table below, all extend HashMap and are based off of the PrinterStateReasons class. Each of these has a different bound combination as seen in the table below. Name Notation Key Value NarrowedIS NIS Integer String GenericKeyIS GKIS Object String GenericValueIS GVIS Integer Object GenericKeyValueIS GKVIS Object Object 5

7 We define four versions of the testing code, one per each of the test classes above, that test our code base by repeatedly calling a method in order to determine its running time. Our tests start with the generic Map interface instantiated as one of our four classes. We then call a method on the interface and the call gets passed down to the specific class. The narrowing happens on the arguments passed from the method in Map to the method in our specific class. The check happens in those classes because in Map the arguments are bound to Object while the narrowed classes are bound to either Integer or String. Note that the type check may be optimized away by the JIT (see Section 3.2). Our test cases, the methods that we are calling in our test classes, for the most part, use a pair of methods that perform an item-by-item search through the HashMap to try to find either a key or value equal to what we pass in. An example of this is the containsvalue method shown below. This is just one of many different methods that we have tested. public boolean containsvalue(v value) { Entry[] tab = table; for (int i = 0; i < tab.length; i++) for (Entry e = tab[i]; e!= null; e = e.next) if (value.equals(e.value)) return true; return false; } This method is a copy of the method in HashMap which we duplicated for studying purposes. The table variable is the array of type Entry that HashMap uses to store its data. Between the four classes of ours, two (NIS and GKIS) have the String type bound for V, and the other two have the Object type bound. Consequently the type of the parameter value in the bytecode is String in NIS and GKIS and Object in GVIS and GKVIS. Map<Integer, String> map = new GKVIS<Integer, String>(); initmap(size, keys, values, map); boolean result = true; double timestart = System.currentTimeMillis() / ; for (int i = 0; i < outerloops; i++) { for (int j = 0; j < 10000; j++) { result &= map.containsvalue(values[j % size]); } } double timeend = System.currentTimeMillis() / ; if (result) { System.out.println(timeEnd - timestart); } initmap() will add items to our Map from our set of keys and values until we reach the size that we pass in. The given arrays have only four distinct elements (repeatedly added to the HashMap as needed) to eliminate the need for garbage collection and thus to guarantee that the running times are not affected by it. We record the start time before we run our 6

8 tests, and then record it again right before the program finishes. The result variable (a boolean) alternates between true and false in the loop and is used after the loop (with the value true since the loop runs an even number of times). We use this dummy variable result so that the JIT compiler does not optimize the method calls away entirely since the JVM compiler will eliminate method calls as useless code if there is no side-effect from the call. In order to obtain running times on the order of seconds, we loop over method calls a large number of times (200,000,000 in examples in this paper). This allows us to accurately measure the differences in time between the test classes. We separate the iteration into doubly nested for loops for easier control of the number loops (the outer loop counter is set as a flag for the test runs). 3.4 Other Test Cases The other methods in HashMap hierarchy that we tested are listed below: IS-put-inl is the same method as put in HashMap, with the test method for it manually inlined into the classes that we are testing, such as NIS, GKIS, etc. The reason for manually inlining the testing method was to explore a particular way of parameter passing in the program. IS-contains-v-inl is the same method as IS-contains-v, with the test method inlined in the same way as IS-put-inl. II-contains-v-inl is the same method IS-contains-v except the type of value is Integer instead of String and its testing method is inlined in the same way as IS-put-inl. 4 Effects and Accuracy of Java Monitoring Tools 4.1 Pattern Classification for Test Cases and Program Stability In our tests we have come across different patterns of time differences between the four test classes, three of which come up in the tests that we describe in this paper. First, there is a no significant difference pattern which is a run where the four classes all run in the same times (we consider differences under 0.4 sec to be non-significant, although most cases in this category are much tighter, often within 0.1 sec). Second, there is the bound narrowing pattern that manifests the bound narrowing delay described in Section 3.2, where the runs with the narrowed value (NIS and GKIS) are slower than the generic runs ( GVIS and GKVIS). The final pattern is what we call the value pattern. The value pattern is where the narrowed value classes are faster than the generic classes. In these runs the JIT successfully optimizes away the bound narrowing delay and then takes advantage of knowing the exact class that the equals method in containsvalue (and in similar methods) is called on. 7

9 The exact target class information allows JIT to inline the method, leading to faster runs for the narrowed tests 1. Our goal is to determine why some runs display a specific pattern. We also discovered that some test cases act differently under different testing conditions, for instance displaying the bound narrowing pattern under the default conditions and the value pattern when tested with HPROF. We refer to runs that exhibit the same pattern for all testing methods (i.e. the default mode of testing, HPROF, Print Compilation and Log Compilation) as stable, and to those that have different patterns as unstable. An unstable test case may also have two different behaviors in the same mode of testing in different tries. In our experience this may happen in Log Compilation tests. In the remainder of the section we show results for some stable and some unstable runs for different ways of testing and discuss the result. All tests are run on the same machine in /tmp to ensure that network problems do not interfere with the tests. Below are the machine and the JVM specifications: AMD AthlonTM 64 Processor MB DDR RAM Fedora Core 7 Kernel: fc7 SMP i686 Java Version: Sun JDK Time Binary: GNU time 1.7 We use the taskset command to pin the JVM process (and all of its subprocesses) to one CPU. 4.2 Results for Default Conditions. In this section we show the results of running the four test cases described in Sections 3.3 and 3.4 under the default conditions in the server mode of the HotSpot JVM. Figure 2 shows the graph for containsvalue corresponding to the data in the table. The graph exhibits the bound narrowing pattern. Due to lack of space we are not showing the graphs for the other three test cases and just summarize all four results in the table: Name NIS GKIS GVIS GKVIS Pattern contains-v BN put-inl BN contains-v-inl Value NII GKII GVII GKVII contains-v-inl No-diff The first column is the name of the test case: containsvalue is the test class explained in Section 3.3, and the other four runs are described in Section 3.4. We make 200,000,000 method calls for each method being tested in each of the four test classes. The numbers 1 In tests that call equals method on a key and not on a value we also found a key pattern which is the same as the value pattern, but it is sped up on runs with a narrowed key (NIS and GVIS) instead of a narrowed value. Due to space limitations we are not describing these tests in the paper. 8

10 CPU Time (sec.) NIS 2GKIS 3GVIS 4GKVIS Server: IS contains v inl , JVM Figure 2: containsvalue, default HotSpot conditions: bound narrowing pattern. are the averages of program running times, in seconds, for 20 repetitions of each test class. The last column shows which pattern the test case follows: BN stands for the bound narrowing pattern, Value stands for the value pattern and No-diff means that there were no significant difference between the four runs. 4.3 Results for HPROF in Method Sampling Mode Figure 3 shows the results of running the IS-contains-v test case with the HPROF profiler in the sampling mode (described in Section 2.3). Not surprisingly, the running time is more that twice that of the original s. This is due to the overhead of collecting the stack sampling information as the program is running. Quite surprisingly, however, the test exhibits the value pattern: the code versions specialized in the value run faster than those with a generic value. This contrasts the bound narrowing pattern of this test under the default conditions. The difference in pattern can clearly be characterized as an observer effect. However, this observer effect is surprising for two reasons. Firstly, unlike the counter mode of HPROF, the sampling mode does not perform bytecode injection. The sampling of the program stack is performed independently from the program itself. Although it requires stopping the program every once in a while to record the contents of the stack, this only adds a constant factor to the program running time and should not affect the relative running times of the four different versions. The second reason this result is unexpected is that most of our test cases (including all three of the comparison runs) are stable with respect to HPROF, i.e. they preserve their default pattern 2 The table below summarizes the results for all four 2 We observed a similar instability in a test similar to IS-contains-v, not shown due to lack of space. 9

11 CPU Time (sec.) NIS 2GKIS 3GVIS 4GKVIS Server: IS contains v inl , JVM with HPROF in sampling mode Figure 3: containsvalue, HPROF in Method Sampling: value pattern test cases. The measurements are determined exactly the same as for the default conditions, except each run is repeated 5 times, not 20. Name NIS GKIS GVIS GKVIS Pattern contains-v Value put-inl BN contains-v-inl Value NII GKII GVII GKVII contains-v-inl No-diff 4.4 Results for Print Compilation and Log Compilation Flags Print compilation results do not change the running time for any of the test cases we have tried, and therefore we are not including its results. Log compilation, however, leads to interesting results for IS-contains-v, see Figure4. Some of the results exhibit bound narrowing pattern, and some have value pattern. These results confirm the fact that IS-contains-v is unstable. They also provide us with compilation logs for both of the patterns that allow us to study the differences in JIT behavior between the bound narrowing and the value pattern of the same program. Section 5 shows the important fragments of the logs and provides discussion. Note that the other three runs are stable, i.e. preserve the default pattern, as shown in the table below. The averages are for five runs per test class. 10

12 CPU Time (sec.) NIS 2GKIS 3GVIS 4GKVIS Server: IS contains v inl , JVM with LogCompilation Figure 4: containsvalue, Log Compilation: split between bound narrowing and value patterns Name NIS GKIS GVIS GKVIS Pattern contains-v 2: : : : Unstable put-inl BN contains-v-inl Value NII GKII GVII GKVII contains-v-inl No-diff 5 Analysis of Compilation Logs and Implications 5.1 Compilation Logs We have provided a sample of two of the logs obtained by the Log Compilation tests of IS-contains-v for the NIS run: one faster run at seconds and one slower run at seconds. We are only showing fragments of the logs for space and clarity reasons since the logs themselves are large XML files. The first of these is a run that exhibited the value pattern and the second exhibited the bound narrowing pattern. For more in depth explanations of the log compilation terms, see [4]. FASTER RUN: First Thread: <klass id="511" name="java/lang/object" flags="1"/> <method id="609" holder="533" name="equals" return="486" 11

13 arguments="511" flags="1" bytes="88" iicount="6611"/> <call method="609" count="4188" prof_factor="1" inline="1"/> <method id="610" holder="533" name="equals" return="486" arguments="511" flags="1" bytes="88" iicount="6612"/> <call method="610" count="4189" prof_factor="1" inline="1"/> Second Thread: <task compile_id="1" compile_kind="osr" method="testnarrowedis main ([Ljava/lang/String;)V" bytes="2330" count="1" backedge_count="14564" iicount="1" osr_bci="942" stamp="0.125"> <method id="715" holder="533" name="equals" return="486" arguments="511" flags="1" bytes="88" iicount="6612"/> <call method="715" count="4189" prof_factor="1" inline="1"/> SLOWER RUN: <task compile_id="1" compile_kind="osr" method="testnarrowedis main ([Ljava/lang/String;)V" bytes="2330" count="10000" backedge_count="5803" iicount="1" osr_bci="942" stamp="0.131"> <klass id="511" name="java/lang/object" flags="1"/> <method id="707" holder="603" name="containsvalue" return="486" arguments="511" flags="4161" bytes="9" compile_id="2" compiler="c2" level="2" iicount="10000"/> <dependency type="unique_concrete_method" ctxk="603" x="707"/> <call method="707" count="35620" prof_factor="1" inline="1"/> <inline_fail reason="already compiled into a big method"/> The abbreviation osr, as seen in the samples, is short for on-stack replacement. On-stack replacement is the process of replacing a method with its more optimized version directly on the program stack as the program is being executed. Log Compilation shows that the JIT runs two separate threads that start at the same time. Our observations show that there is no significance to a particular operation taking place in the first or the second thread. However, we have found that second thread will typically have the optimizations for faster runs. The iicount and backedge count are for how many times the method in question gets called, but they do not seem to be very important. The key is whether or not the test case gets inlined into the calling context successfully. The first run, the faster of the two and showing the value pattern, inlines containsvalue into main first, and it later inlines equals into containsvalue. The second run, the slower of the two and showing the bound narrowing pattern, does things the opposite way, inlining equals into containsvalue first. However, when it tries to inline containsvalue into main, it fails with the reason of already compiled into a big method. This fail reason means that containsvalue was too large after it was inlined with equals to be inlined into main. In this specific test, main was the calling context (see the second code fragment in Section 3.3) of containsvalue. 12

14 The logs for the tests we ran fall under one of three different categories. If, as is the case for IS-put-inl the narrowed test classes fail to inline into the calling context, we get the bound narrowing pattern. IS-put-inl is a more complicated method, and we do not have complete analysis of its compilation log at this point. We observed that in the case of IS-contains-v-inl the narrowed test classes succeed in inlining the testing method into the calling context, but the generic ones fail. This corresponds to the value pattern (the narrowed classes are faster than the generic ones). Finally, when all four of the classes succeed in inlining into the calling context, we get the no significant difference pattern which is the case for II-contains-v-inl. 5.2 Analysis of Compilation Logs and Hypotheses In our analysis of the compilation logs, we have come up with a hypothesis to explain the three different patterns that we have seen. No significant difference shows up if the compilation log has both the narrowed and generic classes succeed in inlining the test case into its calling context. The value pattern shows up if the inlining of the generic classes fails and the inlining of the narrowed succeeds. Bound narrowing shows up if narrowed classes fail to inline the tested method into the calling context, regardless of whether the generic classes succeeds or fails to inline the test case. We have found that if generic fails to inline and narrowed fails, then it shows bound narrowing. We have reason to believe that if generic succeeds inlining then the bound narrowing will be more extreme. In addition, we have observed that test runs with an Integer bound for a value (rather than the String, as in most of our examples) are stable and fall into value pattern or no significant difference, except on put runs. We believe that the reason for this is because the method size of equals in Integer is smaller which make the inlining of the method work irregardless of order. The exception being put because the methods for those runs are larger and fail to inline. 6 Conclusions and Future Work The table below shows the summary of comparing different diagnostic methods: Diagnostic Method Time Change Pattern Change Information Amount Print Compilation no time change no pattern change some hprof(sampling) approximately doubles times can change patterns moderate amount hprof(counting) drastic increase significantly inaccurate Log Compilation no significant change can change the pattern detailed, accurate Print compilation is the method with the least impact, but it does not produce enough information to be able to detect important optimizations, in particular inlining. As shown in [1], HPROF in the method counter mode creates a drastic time increase and may disable inlining, therefore it is not useful for our purposes. The sampling mode of HPROF increases the running times by a moderate amount. However, it may change the behavior of unstable 13

15 programs. Finally, log compilation produces helpful information, but may also change the behavior of unstable programs. We observed that unstable programs may produce different running times in repeated runs with log compilation. We were able to analyze the logs for two runs with the log compilation option that resulted in two different running times. The logs gave us an insight into the behavior related to the bound narrowing inheritance. We were able to identify a sequence of optimizations that leads to failure to inline the method under testing. We developed a hypothesis for explaining the distinction in patterns for our current set of tests. Future work includes analysis of more compilation logs with the goal of generalizing the patterns to other tests, such as those that use put methods which we currently cannot explain. We also plan to check the dependency of this approach on the maximum method size for inlining by setting the JVM flag that controls this parameter. Another promising direction to explore is multithreading in JIT: we can set the number of threads and thus get an indirect control over thread scheduling. Finally, we plan to identify code patterns that lead to program instability. It may be wise to advise programmers to avoid these patterns. References [1] MACHKASOVA, E., ARHELGER, K., AND TRINCIANTE, F. The observer effect of profiling on dynamic java optimizations. In OOPSLA Companion (2009), pp [2] O HAIR, K. HPROF: A Heap/CPU Profiling Tool in J2SE 5.0, [3] ORACLE TECHNOLOGY NETWORK. Frequently Asked Questions About the Java HotSpot VM. [4] ORACLE TECHNOLOGY NETWORK. HotSpot Glossary of Terms. [5] ORACLE TECHNOLOGY NETWORK. Java hotspot vm options. ORACLE. [6] SUN DEVELOPER NETWORK. The java hotspot performance engine architecture. Sun Microsystem (2007). [7] TRINCIANTE, F., SJOBLOM, I., AND MACHKASOVA, E. Choosing efficient inheritance patterns for java generics. In MICS 2010 (2010), pp

Use of profilers for studying Java dynamic optimizations

Use of profilers for studying Java dynamic optimizations Use of profilers for studying Java dynamic optimizations Kevin Arhelger, Fernando Trinciante, Elena Machkasova Computer Science Discipline University of Minnesota Morris Morris MN, 56267 arhel005@umn.edu,

More information

Topics. Introduction. Java History CS 146. Introduction to Programming and Algorithms Module 1. Module Objectives

Topics. Introduction. Java History CS 146. Introduction to Programming and Algorithms Module 1. Module Objectives Introduction to Programming and Algorithms Module 1 CS 146 Sam Houston State University Dr. Tim McGuire Module Objectives To understand: the necessity of programming, differences between hardware and software,

More information

Interpreters and virtual machines. Interpreters. Interpreters. Why interpreters? Tree-based interpreters. Text-based interpreters

Interpreters and virtual machines. Interpreters. Interpreters. Why interpreters? Tree-based interpreters. Text-based interpreters Interpreters and virtual machines Michel Schinz 2007 03 23 Interpreters Interpreters Why interpreters? An interpreter is a program that executes another program, represented as some kind of data-structure.

More information

Characteristics of Java (Optional) Y. Daniel Liang Supplement for Introduction to Java Programming

Characteristics of Java (Optional) Y. Daniel Liang Supplement for Introduction to Java Programming Characteristics of Java (Optional) Y. Daniel Liang Supplement for Introduction to Java Programming Java has become enormously popular. Java s rapid rise and wide acceptance can be traced to its design

More information

CSC 551: Web Programming. Spring 2004

CSC 551: Web Programming. Spring 2004 CSC 551: Web Programming Spring 2004 Java Overview Design goals & features platform independence, portable, secure, simple, object-oriented, Programming models applications vs. applets vs. servlets intro

More information

1. Overview of the Java Language

1. Overview of the Java Language 1. Overview of the Java Language What Is the Java Technology? Java technology is: A programming language A development environment An application environment A deployment environment It is similar in syntax

More information

CSCI E 98: Managed Environments for the Execution of Programs

CSCI E 98: Managed Environments for the Execution of Programs CSCI E 98: Managed Environments for the Execution of Programs Draft Syllabus Instructor Phil McGachey, PhD Class Time: Mondays beginning Sept. 8, 5:30-7:30 pm Location: 1 Story Street, Room 304. Office

More information

Java Coding Practices for Improved Application Performance

Java Coding Practices for Improved Application Performance 1 Java Coding Practices for Improved Application Performance Lloyd Hagemo Senior Director Application Infrastructure Management Group Candle Corporation In the beginning, Java became the language of the

More information

Habanero Extreme Scale Software Research Project

Habanero Extreme Scale Software Research Project Habanero Extreme Scale Software Research Project Comp215: Java Method Dispatch Zoran Budimlić (Rice University) Always remember that you are absolutely unique. Just like everyone else. - Margaret Mead

More information

Java and Real Time Storage Applications

Java and Real Time Storage Applications Java and Real Time Storage Applications Gary Mueller Janet Borzuchowski 1 Flavors of Java for Embedded Systems Software Java Virtual Machine(JVM) Compiled Java Hardware Java Virtual Machine Java Virtual

More information

Performance Measurement of Dynamically Compiled Java Executions

Performance Measurement of Dynamically Compiled Java Executions Performance Measurement of Dynamically Compiled Java Executions Tia Newhall and Barton P. Miller University of Wisconsin Madison Madison, WI 53706-1685 USA +1 (608) 262-1204 {newhall,bart}@cs.wisc.edu

More information

picojava TM : A Hardware Implementation of the Java Virtual Machine

picojava TM : A Hardware Implementation of the Java Virtual Machine picojava TM : A Hardware Implementation of the Java Virtual Machine Marc Tremblay and Michael O Connor Sun Microelectronics Slide 1 The Java picojava Synergy Java s origins lie in improving the consumer

More information

Java Garbage Collection Basics

Java Garbage Collection Basics Java Garbage Collection Basics Overview Purpose This tutorial covers the basics of how Garbage Collection works with the Hotspot JVM. Once you have learned how the garbage collector functions, learn how

More information

Online Recruitment System 1. INTRODUCTION

Online Recruitment System 1. INTRODUCTION 1. INTRODUCTION This project Online Recruitment System is an online website in which jobseekers can register themselves online and apply for job and attend the exam. Online Recruitment System provides

More information

14/05/2013 Ed Merks EDL V1.0 1

14/05/2013 Ed Merks EDL V1.0 1 14/05/2013 Ed Merks EDL V1.0 1 Java Performance is Complex Write once run everywhere Java is slow because it s interpreted No, there are Just In Time (JIT) compilers Different hardware and platforms Different

More information

NetBeans Profiler is an

NetBeans Profiler is an NetBeans Profiler Exploring the NetBeans Profiler From Installation to a Practical Profiling Example* Gregg Sporar* NetBeans Profiler is an optional feature of the NetBeans IDE. It is a powerful tool that

More information

Advanced compiler construction. General course information. Teacher & assistant. Course goals. Evaluation. Grading scheme. Michel Schinz 2007 03 16

Advanced compiler construction. General course information. Teacher & assistant. Course goals. Evaluation. Grading scheme. Michel Schinz 2007 03 16 Advanced compiler construction Michel Schinz 2007 03 16 General course information Teacher & assistant Course goals Teacher: Michel Schinz Michel.Schinz@epfl.ch Assistant: Iulian Dragos INR 321, 368 64

More information

Jonathan Worthington Scarborough Linux User Group

Jonathan Worthington Scarborough Linux User Group Jonathan Worthington Scarborough Linux User Group Introduction What does a Virtual Machine do? Hides away the details of the hardware platform and operating system. Defines a common set of instructions.

More information

Envox CDP 7.0 Performance Comparison of VoiceXML and Envox Scripts

Envox CDP 7.0 Performance Comparison of VoiceXML and Envox Scripts Envox CDP 7.0 Performance Comparison of and Envox Scripts Goal and Conclusion The focus of the testing was to compare the performance of and ENS applications. It was found that and ENS applications have

More information

Chapter 1 Fundamentals of Java Programming

Chapter 1 Fundamentals of Java Programming Chapter 1 Fundamentals of Java Programming Computers and Computer Programming Writing and Executing a Java Program Elements of a Java Program Features of Java Accessing the Classes and Class Members The

More information

Java and the JVM. Martin Schöberl

Java and the JVM. Martin Schöberl Java and the JVM Martin Schöberl Overview History and Java features Java technology The Java language A first look into the JVM Disassembling of.class files Java and the JVM 2 History of a Young Java 1992

More information

The Java Series. Java Essentials I What is Java? Basic Language Constructs. Java Essentials I. What is Java?. Basic Language Constructs Slide 1

The Java Series. Java Essentials I What is Java? Basic Language Constructs. Java Essentials I. What is Java?. Basic Language Constructs Slide 1 The Java Series Java Essentials I What is Java? Basic Language Constructs Slide 1 What is Java? A general purpose Object Oriented programming language. Created by Sun Microsystems. It s a general purpose

More information

Replication on Virtual Machines

Replication on Virtual Machines Replication on Virtual Machines Siggi Cherem CS 717 November 23rd, 2004 Outline 1 Introduction The Java Virtual Machine 2 Napper, Alvisi, Vin - DSN 2003 Introduction JVM as state machine Addressing non-determinism

More information

Handout 1. Introduction to Java programming language. Java primitive types and operations. Reading keyboard Input using class Scanner.

Handout 1. Introduction to Java programming language. Java primitive types and operations. Reading keyboard Input using class Scanner. Handout 1 CS603 Object-Oriented Programming Fall 15 Page 1 of 11 Handout 1 Introduction to Java programming language. Java primitive types and operations. Reading keyboard Input using class Scanner. Java

More information

language 1 (source) compiler language 2 (target) Figure 1: Compiling a program

language 1 (source) compiler language 2 (target) Figure 1: Compiling a program CS 2112 Lecture 27 Interpreters, compilers, and the Java Virtual Machine 1 May 2012 Lecturer: Andrew Myers 1 Interpreters vs. compilers There are two strategies for obtaining runnable code from a program

More information

INTRODUCTION TO JAVA PROGRAMMING LANGUAGE

INTRODUCTION TO JAVA PROGRAMMING LANGUAGE INTRODUCTION TO JAVA PROGRAMMING LANGUAGE Today Java programming language is one of the most popular programming language which is used in critical applications like stock market trading system on BSE,

More information

Tuning WebSphere Application Server ND 7.0. Royal Cyber Inc.

Tuning WebSphere Application Server ND 7.0. Royal Cyber Inc. Tuning WebSphere Application Server ND 7.0 Royal Cyber Inc. JVM related problems Application server stops responding Server crash Hung process Out of memory condition Performance degradation Check if the

More information

Garbage Collection in the Java HotSpot Virtual Machine

Garbage Collection in the Java HotSpot Virtual Machine http://www.devx.com Printed from http://www.devx.com/java/article/21977/1954 Garbage Collection in the Java HotSpot Virtual Machine Gain a better understanding of how garbage collection in the Java HotSpot

More information

Object Instance Profiling

Object Instance Profiling Object Instance Profiling Lubomír Bulej 1,2, Lukáš Marek 1, Petr Tůma 1 Technical report No. 2009/7, November 2009 Version 1.0, November 2009 1 Distributed Systems Research Group, Department of Software

More information

11.1 inspectit. 11.1. inspectit

11.1 inspectit. 11.1. inspectit 11.1. inspectit Figure 11.1. Overview on the inspectit components [Siegl and Bouillet 2011] 11.1 inspectit The inspectit monitoring tool (website: http://www.inspectit.eu/) has been developed by NovaTec.

More information

Validating Java for Safety-Critical Applications

Validating Java for Safety-Critical Applications Validating Java for Safety-Critical Applications Jean-Marie Dautelle * Raytheon Company, Marlborough, MA, 01752 With the real-time extensions, Java can now be used for safety critical systems. It is therefore

More information

02 B The Java Virtual Machine

02 B The Java Virtual Machine 02 B The Java Virtual Machine CS1102S: Data Structures and Algorithms Martin Henz January 22, 2010 Generated on Friday 22 nd January, 2010, 09:46 CS1102S: Data Structures and Algorithms 02 B The Java Virtual

More information

Practical Performance Understanding the Performance of Your Application

Practical Performance Understanding the Performance of Your Application Neil Masson IBM Java Service Technical Lead 25 th September 2012 Practical Performance Understanding the Performance of Your Application 1 WebSphere User Group: Practical Performance Understand the Performance

More information

Multi-core Programming System Overview

Multi-core Programming System Overview Multi-core Programming System Overview Based on slides from Intel Software College and Multi-Core Programming increasing performance through software multi-threading by Shameem Akhter and Jason Roberts,

More information

School of Informatics, University of Edinburgh

School of Informatics, University of Edinburgh CS1Bh Lecture Note 7 Compilation I: Java Byte Code High-level programming languages are compiled to equivalent low-level programs which are executed on a given machine. The process of compiling a program

More information

Cloud Computing. Up until now

Cloud Computing. Up until now Cloud Computing Lecture 11 Virtualization 2011-2012 Up until now Introduction. Definition of Cloud Computing Grid Computing Content Distribution Networks Map Reduce Cycle-Sharing 1 Process Virtual Machines

More information

Compiling Object Oriented Languages. What is an Object-Oriented Programming Language? Implementation: Dynamic Binding

Compiling Object Oriented Languages. What is an Object-Oriented Programming Language? Implementation: Dynamic Binding Compiling Object Oriented Languages What is an Object-Oriented Programming Language? Last time Dynamic compilation Today Introduction to compiling object oriented languages What are the issues? Objects

More information

The Java Virtual Machine and Mobile Devices. John Buford, Ph.D. buford@alum.mit.edu Oct 2003 Presented to Gordon College CS 311

The Java Virtual Machine and Mobile Devices. John Buford, Ph.D. buford@alum.mit.edu Oct 2003 Presented to Gordon College CS 311 The Java Virtual Machine and Mobile Devices John Buford, Ph.D. buford@alum.mit.edu Oct 2003 Presented to Gordon College CS 311 Objectives Review virtual machine concept Introduce stack machine architecture

More information

Checking Access to Protected Members in the Java Virtual Machine

Checking Access to Protected Members in the Java Virtual Machine Checking Access to Protected Members in the Java Virtual Machine Alessandro Coglio Kestrel Institute 3260 Hillview Avenue, Palo Alto, CA 94304, USA Ph. +1-650-493-6871 Fax +1-650-424-1807 http://www.kestrel.edu/

More information

Debugging Java Applications

Debugging Java Applications Debugging Java Applications Table of Contents Starting a Debugging Session...2 Debugger Windows...4 Attaching the Debugger to a Running Application...5 Starting the Debugger Outside of the Project's Main

More information

Tool - 1: Health Center

Tool - 1: Health Center Tool - 1: Health Center Joseph Amrith Raj http://facebook.com/webspherelibrary 2 Tool - 1: Health Center Table of Contents WebSphere Application Server Troubleshooting... Error! Bookmark not defined. About

More information

qwertyuiopasdfghjklzxcvbnmqwerty uiopasdfghjklzxcvbnmqwertyuiopasd fghjklzxcvbnmqwertyuiopasdfghjklzx cvbnmqwertyuiopasdfghjklzxcvbnmq

qwertyuiopasdfghjklzxcvbnmqwerty uiopasdfghjklzxcvbnmqwertyuiopasd fghjklzxcvbnmqwertyuiopasdfghjklzx cvbnmqwertyuiopasdfghjklzxcvbnmq qwertyuiopasdfghjklzxcvbnmqwerty uiopasdfghjklzxcvbnmqwertyuiopasd fghjklzxcvbnmqwertyuiopasdfghjklzx cvbnmqwertyuiopasdfghjklzxcvbnmq Introduction to Programming using Java wertyuiopasdfghjklzxcvbnmqwertyui

More information

Outline. hardware components programming environments. installing Python executing Python code. decimal and binary notations running Sage

Outline. hardware components programming environments. installing Python executing Python code. decimal and binary notations running Sage Outline 1 Computer Architecture hardware components programming environments 2 Getting Started with Python installing Python executing Python code 3 Number Systems decimal and binary notations running

More information

Java Interview Questions and Answers

Java Interview Questions and Answers 1. What is the most important feature of Java? Java is a platform independent language. 2. What do you mean by platform independence? Platform independence means that we can write and compile the java

More information

Instrumentation Software Profiling

Instrumentation Software Profiling Instrumentation Software Profiling Software Profiling Instrumentation of a program so that data related to runtime performance (e.g execution time, memory usage) is gathered for one or more pieces of the

More information

System Structures. Services Interface Structure

System Structures. Services Interface Structure System Structures Services Interface Structure Operating system services (1) Operating system services (2) Functions that are helpful to the user User interface Command line interpreter Batch interface

More information

Monitoring, Tracing, Debugging (Under Construction)

Monitoring, Tracing, Debugging (Under Construction) Monitoring, Tracing, Debugging (Under Construction) I was already tempted to drop this topic from my lecture on operating systems when I found Stephan Siemen's article "Top Speed" in Linux World 10/2003.

More information

The Hotspot Java Virtual Machine: Memory and Architecture

The Hotspot Java Virtual Machine: Memory and Architecture International Journal of Allied Practice, Research and Review Website: www.ijaprr.com (ISSN 2350-1294) The Hotspot Java Virtual Machine: Memory and Architecture Prof. Tejinder Singh Assistant Professor,

More information

Java Programming Fundamentals

Java Programming Fundamentals Lecture 1 Part I Java Programming Fundamentals Topics in Quantitative Finance: Numerical Solutions of Partial Differential Equations Instructor: Iraj Kani Introduction to Java We start by making a few

More information

2 Introduction to Java. Introduction to Programming 1 1

2 Introduction to Java. Introduction to Programming 1 1 2 Introduction to Java Introduction to Programming 1 1 Objectives At the end of the lesson, the student should be able to: Describe the features of Java technology such as the Java virtual machine, garbage

More information

Fachbereich Informatik und Elektrotechnik SunSPOT. Ubiquitous Computing. Ubiquitous Computing, Helmut Dispert

Fachbereich Informatik und Elektrotechnik SunSPOT. Ubiquitous Computing. Ubiquitous Computing, Helmut Dispert Ubiquitous Computing Ubiquitous Computing The Sensor Network System Sun SPOT: The Sun Small Programmable Object Technology Technology-Based Wireless Sensor Networks a Java Platform for Developing Applications

More information

technical brief Optimizing Performance in HP Web Jetadmin Web Jetadmin Overview Performance HP Web Jetadmin CPU Utilization utilization.

technical brief Optimizing Performance in HP Web Jetadmin Web Jetadmin Overview Performance HP Web Jetadmin CPU Utilization utilization. technical brief in HP Overview HP is a Web-based software application designed to install, configure, manage and troubleshoot network-connected devices. It includes a Web service, which allows multiple

More information

Crash Course in Java

Crash Course in Java Crash Course in Java Based on notes from D. Hollinger Based in part on notes from J.J. Johns also: Java in a Nutshell Java Network Programming and Distributed Computing Netprog 2002 Java Intro 1 What is

More information

Performance Monitoring API for Java Enterprise Applications

Performance Monitoring API for Java Enterprise Applications Performance Monitoring API for Java Enterprise Applications Purpose Perfmon4j has been successfully deployed in hundreds of production java systems over the last 5 years. It has proven to be a highly successful

More information

On Performance of Delegation in Java

On Performance of Delegation in Java On Performance of Delegation in Java Sebastian Götz Software Technology Group, Dresden University of Technology, Germany sebastian.goetz@mail.inf.tu-dresden.de Mario Pukall Database Research Group, Otto-von-Guericke-University

More information

Virtual Machines. www.viplavkambli.com

Virtual Machines. www.viplavkambli.com 1 Virtual Machines A virtual machine (VM) is a "completely isolated guest operating system installation within a normal host operating system". Modern virtual machines are implemented with either software

More information

PERFORMANCE ENHANCEMENTS IN TreeAge Pro 2014 R1.0

PERFORMANCE ENHANCEMENTS IN TreeAge Pro 2014 R1.0 PERFORMANCE ENHANCEMENTS IN TreeAge Pro 2014 R1.0 15 th January 2014 Al Chrosny Director, Software Engineering TreeAge Software, Inc. achrosny@treeage.com Andrew Munzer Director, Training and Customer

More information

Chapter 3: Operating-System Structures. Common System Components

Chapter 3: Operating-System Structures. Common System Components Chapter 3: Operating-System Structures System Components Operating System Services System Calls System Programs System Structure Virtual Machines System Design and Implementation System Generation 3.1

More information

TECHNOLOGY WHITE PAPER. Application Performance Management. Introduction to Adaptive Instrumentation with VERITAS Indepth for J2EE

TECHNOLOGY WHITE PAPER. Application Performance Management. Introduction to Adaptive Instrumentation with VERITAS Indepth for J2EE TECHNOLOGY WHITE PAPER Application Performance Management Introduction to Adaptive Instrumentation with VERITAS Indepth for J2EE TABLE OF CONTENTS ABOUT ADAPTIVE INSTRUMENTATION 3 WHY ADAPTIVE INSTRUMENTATION?

More information

Full and Para Virtualization

Full and Para Virtualization Full and Para Virtualization Dr. Sanjay P. Ahuja, Ph.D. 2010-14 FIS Distinguished Professor of Computer Science School of Computing, UNF x86 Hardware Virtualization The x86 architecture offers four levels

More information

ATSBA: Advanced Technologies Supporting Business Areas. Programming with Java. 1 Overview and Introduction

ATSBA: Advanced Technologies Supporting Business Areas. Programming with Java. 1 Overview and Introduction ATSBA: Advanced Technologies Supporting Business Areas Programming with Java 1 Overview and Introduction 1 1 Overview and Introduction 1 Overview and Introduction 1.1 Programming and Programming Languages

More information

Glossary of Object Oriented Terms

Glossary of Object Oriented Terms Appendix E Glossary of Object Oriented Terms abstract class: A class primarily intended to define an instance, but can not be instantiated without additional methods. abstract data type: An abstraction

More information

Reconfigurable Architecture Requirements for Co-Designed Virtual Machines

Reconfigurable Architecture Requirements for Co-Designed Virtual Machines Reconfigurable Architecture Requirements for Co-Designed Virtual Machines Kenneth B. Kent University of New Brunswick Faculty of Computer Science Fredericton, New Brunswick, Canada ken@unb.ca Micaela Serra

More information

enterprise professional expertise distilled

enterprise professional expertise distilled Oracle JRockit The Definitive Guide Develop and manage robust Java applications with Oracle's high-performance Java Virtual Machine Marcus Hirt Marcus Lagergren PUBLISHING enterprise professional expertise

More information

Performance Improvement In Java Application

Performance Improvement In Java Application Performance Improvement In Java Application Megha Fulfagar Accenture Delivery Center for Technology in India Accenture, its logo, and High Performance Delivered are trademarks of Accenture. Agenda Performance

More information

Experimental Evaluation of Distributed Middleware with a Virtualized Java Environment

Experimental Evaluation of Distributed Middleware with a Virtualized Java Environment Experimental Evaluation of Distributed Middleware with a Virtualized Java Environment Nuno A. Carvalho, João Bordalo, Filipe Campos and José Pereira HASLab / INESC TEC Universidade do Minho MW4SOC 11 December

More information

1/20/2016 INTRODUCTION

1/20/2016 INTRODUCTION INTRODUCTION 1 Programming languages have common concepts that are seen in all languages This course will discuss and illustrate these common concepts: Syntax Names Types Semantics Memory Management We

More information

WebSphere Performance Monitoring & Tuning For Webtop Version 5.3 on WebSphere 5.1.x

WebSphere Performance Monitoring & Tuning For Webtop Version 5.3 on WebSphere 5.1.x Frequently Asked Questions WebSphere Performance Monitoring & Tuning For Webtop Version 5.3 on WebSphere 5.1.x FAQ Version 1.0 External FAQ1. Q. How do I monitor Webtop performance in WebSphere? 1 Enabling

More information

What s Cool in the SAP JVM (CON3243)

What s Cool in the SAP JVM (CON3243) What s Cool in the SAP JVM (CON3243) Volker Simonis, SAP SE September, 2014 Public Agenda SAP JVM Supportability SAP JVM Profiler SAP JVM Debugger 2014 SAP SE. All rights reserved. Public 2 SAP JVM SAP

More information

Analysis of VDI Storage Performance During Bootstorm

Analysis of VDI Storage Performance During Bootstorm Analysis of VDI Storage Performance During Bootstorm Introduction Virtual desktops are gaining popularity as a more cost effective and more easily serviceable solution. The most resource-dependent process

More information

An Evaluation of OpenMP on Current and Emerging Multithreaded/Multicore Processors

An Evaluation of OpenMP on Current and Emerging Multithreaded/Multicore Processors An Evaluation of OpenMP on Current and Emerging Multithreaded/Multicore Processors Matthew Curtis-Maury, Xiaoning Ding, Christos D. Antonopoulos, and Dimitrios S. Nikolopoulos The College of William &

More information

Liferay Portal Performance. Benchmark Study of Liferay Portal Enterprise Edition

Liferay Portal Performance. Benchmark Study of Liferay Portal Enterprise Edition Liferay Portal Performance Benchmark Study of Liferay Portal Enterprise Edition Table of Contents Executive Summary... 3 Test Scenarios... 4 Benchmark Configuration and Methodology... 5 Environment Configuration...

More information

Programming Languages

Programming Languages Programming Languages In the beginning To use a computer, you needed to know how to program it. Today People no longer need to know how to program in order to use the computer. To see how this was accomplished,

More information

Explain the relationship between a class and an object. Which is general and which is specific?

Explain the relationship between a class and an object. Which is general and which is specific? A.1.1 What is the Java Virtual Machine? Is it hardware or software? How does its role differ from that of the Java compiler? The Java Virtual Machine (JVM) is software that simulates the execution of a

More information

An Oracle White Paper September 2013. Advanced Java Diagnostics and Monitoring Without Performance Overhead

An Oracle White Paper September 2013. Advanced Java Diagnostics and Monitoring Without Performance Overhead An Oracle White Paper September 2013 Advanced Java Diagnostics and Monitoring Without Performance Overhead Introduction... 1 Non-Intrusive Profiling and Diagnostics... 2 JMX Console... 2 Java Flight Recorder...

More information

The Design of the Inferno Virtual Machine. Introduction

The Design of the Inferno Virtual Machine. Introduction The Design of the Inferno Virtual Machine Phil Winterbottom Rob Pike Bell Labs, Lucent Technologies {philw, rob}@plan9.bell-labs.com http://www.lucent.com/inferno Introduction Virtual Machine are topical

More information

Oracle JRockit JVM. Diagnostics Guide R27.6. April 2009

Oracle JRockit JVM. Diagnostics Guide R27.6. April 2009 Oracle JRockit JVM Diagnostics Guide R27.6 April 2009 Oracle JRockit JVM Diagnostics Guide, R27.6 Copyright 2007, 2008, Oracle and/or its affiliates. All rights reserved. This software and related documentation

More information

2 2011 Oracle Corporation Proprietary and Confidential

2 2011 Oracle Corporation Proprietary and Confidential The following is intended to outline our general product direction. It is intended for information purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any material,

More information

CSC230 Getting Starting in C. Tyler Bletsch

CSC230 Getting Starting in C. Tyler Bletsch CSC230 Getting Starting in C Tyler Bletsch What is C? The language of UNIX Procedural language (no classes) Low-level access to memory Easy to map to machine language Not much run-time stuff needed Surprisingly

More information

Last Class: OS and Computer Architecture. Last Class: OS and Computer Architecture

Last Class: OS and Computer Architecture. Last Class: OS and Computer Architecture Last Class: OS and Computer Architecture System bus Network card CPU, memory, I/O devices, network card, system bus Lecture 3, page 1 Last Class: OS and Computer Architecture OS Service Protection Interrupts

More information

Developing Embedded Software in Java Part 1: Technology and Architecture

Developing Embedded Software in Java Part 1: Technology and Architecture Developing Embedded Software in Java Part 1: Technology and Architecture by Michael Barr Embedded Systems Conference Europe The Netherlands November 16-18, 1999 Course #300 Sun s introduction of the Java

More information

Java Virtual Machine: the key for accurated memory prefetching

Java Virtual Machine: the key for accurated memory prefetching Java Virtual Machine: the key for accurated memory prefetching Yolanda Becerra Jordi Garcia Toni Cortes Nacho Navarro Computer Architecture Department Universitat Politècnica de Catalunya Barcelona, Spain

More information

How accurately do Java profilers predict runtime performance bottlenecks?

How accurately do Java profilers predict runtime performance bottlenecks? How accurately do Java profilers predict runtime performance bottlenecks? Master Software Engineering How accurately do Java profilers predict runtime performance bottlenecks? Peter Klijn: Student number

More information

What Is Specific in Load Testing?

What Is Specific in Load Testing? What Is Specific in Load Testing? Testing of multi-user applications under realistic and stress loads is really the only way to ensure appropriate performance and reliability in production. Load testing

More information

Fundamentals of Java Programming

Fundamentals of Java Programming Fundamentals of Java Programming This document is exclusive property of Cisco Systems, Inc. Permission is granted to print and copy this document for non-commercial distribution and exclusive use by instructors

More information

Java Garbage Collection Characteristics and Tuning Guidelines for Apache Hadoop TeraSort Workload

Java Garbage Collection Characteristics and Tuning Guidelines for Apache Hadoop TeraSort Workload Java Garbage Collection Characteristics and Tuning Guidelines for Apache Hadoop TeraSort Workload Shrinivas Joshi, Software Performance Engineer Vasileios Liaskovitis, Performance Engineer 1. Introduction

More information

Effective Java Programming. efficient software development

Effective Java Programming. efficient software development Effective Java Programming efficient software development Structure efficient software development what is efficiency? development process profiling during development what determines the performance of

More information

Java (12 Weeks) Introduction to Java Programming Language

Java (12 Weeks) Introduction to Java Programming Language Java (12 Weeks) Topic Lecture No. Introduction to Java Programming Language 1 An Introduction to Java o Java as a Programming Platform, The Java "White Paper" Buzzwords, Java and the Internet, A Short

More information

core. Volume I - Fundamentals Seventh Edition Sun Microsystems Press A Prentice Hall Title ULB Darmstadt

core. Volume I - Fundamentals Seventh Edition Sun Microsystems Press A Prentice Hall Title ULB Darmstadt core. 2008 AGI-Information Management Consultants May be used for personal purporses only or by libraries associated to dandelon.com network. Volume I - Fundamentals Seventh Edition CAY S. HORSTMANN GARY

More information

An Easier Way for Cross-Platform Data Acquisition Application Development

An Easier Way for Cross-Platform Data Acquisition Application Development An Easier Way for Cross-Platform Data Acquisition Application Development For industrial automation and measurement system developers, software technology continues making rapid progress. Software engineers

More information

General Introduction

General Introduction Managed Runtime Technology: General Introduction Xiao-Feng Li (xiaofeng.li@gmail.com) 2012-10-10 Agenda Virtual machines Managed runtime systems EE and MM (JIT and GC) Summary 10/10/2012 Managed Runtime

More information

C# and Other Languages

C# and Other Languages C# and Other Languages Rob Miles Department of Computer Science Why do we have lots of Programming Languages? Different developer audiences Different application areas/target platforms Graphics, AI, List

More information

Delivering Quality in Software Performance and Scalability Testing

Delivering Quality in Software Performance and Scalability Testing Delivering Quality in Software Performance and Scalability Testing Abstract Khun Ban, Robert Scott, Kingsum Chow, and Huijun Yan Software and Services Group, Intel Corporation {khun.ban, robert.l.scott,

More information

Video Performance in Java

Video Performance in Java Video Performance in Java Mark Claypool, Tom Coates, Shawn Hooley, Eric Shea and Chris Spellacy ABSTRACT The tremendous growth in both Java and multimedia present an opportunity for cross-platform multimedia

More information

Characterizing Java Virtual Machine for More Efficient Processor Power Management. Abstract

Characterizing Java Virtual Machine for More Efficient Processor Power Management. Abstract Characterizing Java Virtual Machine for More Efficient Processor Power Management Marcelo S. Quijano, Lide Duan Department of Electrical and Computer Engineering University of Texas at San Antonio hrk594@my.utsa.edu,

More information

2 Programs: Instructions in the Computer

2 Programs: Instructions in the Computer 2 2 Programs: Instructions in the Computer Figure 2. illustrates the first few processing steps taken as a simple CPU executes a program. The CPU for this example is assumed to have a program counter (PC),

More information

C Compiler Targeting the Java Virtual Machine

C Compiler Targeting the Java Virtual Machine C Compiler Targeting the Java Virtual Machine Jack Pien Senior Honors Thesis (Advisor: Javed A. Aslam) Dartmouth College Computer Science Technical Report PCS-TR98-334 May 30, 1998 Abstract One of the

More information

EVALUATION. WA1844 WebSphere Process Server 7.0 Programming Using WebSphere Integration COPY. Developer

EVALUATION. WA1844 WebSphere Process Server 7.0 Programming Using WebSphere Integration COPY. Developer WA1844 WebSphere Process Server 7.0 Programming Using WebSphere Integration Developer Web Age Solutions Inc. USA: 1-877-517-6540 Canada: 1-866-206-4644 Web: http://www.webagesolutions.com Chapter 6 - Introduction

More information

CS 209 Programming in Java #1

CS 209 Programming in Java #1 CS 209 Programming in Java #1 Introduction Spring, 2006 Instructor: J.G. Neal 1 Topics CS 209 Target Audience CS 209 Course Goals CS 209 Syllabus - See handout Java Features, History, Environment Java

More information

Moving from CS 61A Scheme to CS 61B Java

Moving from CS 61A Scheme to CS 61B Java Moving from CS 61A Scheme to CS 61B Java Introduction Java is an object-oriented language. This document describes some of the differences between object-oriented programming in Scheme (which we hope you

More information