JAVA ON HANDHELD DEVICES COMPARING J2ME CDC TO JAVA 1.1 AND JAVA 2
|
|
- Johnathan Wiggins
- 5 years ago
- Views:
Transcription
1 JAVA ON HANDHELD DEVICES COMPARING J2ME CDC TO JAVA 1.1 AND JAVA 2 Mikko Laukkanen Abstract: The current trend is towards having Java applications run on handheld mobile devices. Sun Microsystems, Inc. has addressed this trend by specifying an edition, namely Java 2 Micro Edition (J2ME), of the Java environment for handheld devices. J2ME divides into two configurations: Connection Limited Device Configuration (CLCD) and Connected Device Configuration (CDC). This paper focuses on the latter, which is targeted at nextgeneration embedded devices, such as handheld computers. Sun Microsystems, Inc. has released CDC specification, a white paper and a reference implementation, which are our main references for this paper. We will give an overview to J2ME and especially CDC, and take a practical view to CDC by testing the reference implementation using several test cases. We also compare CDC to Java 2 and Java 1.1 standard editions. Java 2 is chosen, because according to Sun, CDC should comply with Java 2, except Swingclasses. For this reason, we do not take Swing into account in our tests. Java 1.1 on the other hand is taken into account, because most of the today s JVMs on handheld devices are based on Java 1.1 functionality. 19
2 20 1 INTRODUCTION The Java 2 Micro Edition (J2ME) is a Java platform targeted at consumer electronics and embedded devices. The J2ME technology consists of a Java Virtual Machine (JVM) and a set of APIs for providing a complete runtime environment for the target device. The J2ME technology has two primary kinds of components configurations and profiles. A configuration is composed of a low-level API and an optimized JVM. At the time of writing, two configurations are available: Connection Limited Device Configuration (CLCD), which is targeted at environments, where Kb of memory is available for the Java environment and applications and Connected Device Configuration (CDC), which is targeted at environments, where more than 512Kb, usually about 2Mb, of memory is available for the Java environment and applications. A profile is a specification that details the Java technology APIs, which are built on top of a configuration. Profile utilizes the underlying configuration to provide a complete runtime environment for a specific kind of device. Figure 1 illustrates, how the configurations and profiles in J2ME relates to each other. On the bottom there is the target device and its operating system, which the configuration is specifically built for. The lowest layer of the configuration is the JVM, of which there are two choices based on the configuration used; K Virtual Machine (KVM) is meant for CLCD and C Virtual Machine (CVM) for CDC. The upper layer of the configuration is composed of a core class library, which includes the classes needed to get the JVM up and running. On top of configuration there are profiles, which add the functionality needed to get applications running. For CLCD there are currently two profiles, Mobile Information Device Profile (MIDP) and Personal Digital Assistant (PDA), whereas in the case of CDC all the profiles are built by extending the Foundation Profile. Personal and RMI Profile are the two options for CDC currently. With Personal Profile the CDC is compliant with the PersonalJava specification [1]. RMI Profile adds the support for Java RMI to the CDC. In this paper we concentrate on CDC and the Foundation Profile. CDC includes CVM, which can be thought as being a small-footprint version of Java 2 virtual machine. For a complete runtime environment, CDC uses the Foundation Profile, which is a set of Java APIs that provide the same APIs as the Java 2 environment. Sun Microsystems, Inc has released the CDC specification [2], a technical white paper [3] and a reference implementation [4], which we will use as main sources of information in this paper. In these references Sun claims many optimizations in both performance and footprint. In this paper we take a practical look at CDC by running various test cases on it and thereby verifying if the claims hold. Various aspects of CDC are studied, such as static and dynamic memory footprints and runtime performance. We also compare CDC to Java 2 and Java 1.1 standard editions. Java 2 is chosen, because according to Sun, CDC should comply with Java 2, except Swing-classes.
3 21 MIDP PDA Personal RMI Foundation Profile libraries CLDC Libraries KVM CDC Libraries CVM Configuration libraries JVM Operating System OS Figure 1 J2ME architecture with configurations and profiles For this reason, we do not take Swing into account in our tests. Java 1.1 on the other hand is taken into account, because most of the today s JVMs on handheld devices are based on Java 1.1 functionality [1, 5, 6]. Furthermore, the reference implementation currently supports only Linux and VxWorks 1. Of the target devices for CDC, Compaq ipaq H3600 series handheld devices are currently one of the few that run Linux and could be considered as a real target device for CDC 2. This paper is organized as follows. In Section 2 we give a more detailed introduction to CDC. Section 3 points out some aspects of running Java on small devices. Section 4 discusses the differencies between CDC, Java 1.1 and Java 2. In Section 5 we analyse the CDC as an option for a Java environment on small devices. Finally, Section 6 concludes this paper. 1 VxWorks is a realtime operating system from WindRiver, who is specialized in embedded platforms, for instance PDA devices. 2 For more information on running Linux on Compaq ipaq, see
4 22 2 CONNECTED DEVICE CONFIGURATION CDC is a Java Community Process effort (JSR-36) that has standardized a portable, Java technology building block for consumer electronic and embedded devices. The CDC standardization effort was the result of a collaboration of companies representing the consumer electronic industry. CDC contains the full Java 2 Platform virtual machine (CVM) and the minimal class libraries and APIs to get the system up and running. For an application to do useful work, the Foundation Profile is required. It includes all the class libraries and APIs that are designed for consumer devices. However, the Foundation Profile does not include GUI classes. Thus, other profiles would be required if an application a GUI. Personal Java applications can be easily ported to CDC. Also, CLCD-compliant profile is upwardly compatible with CDC. Target devices for CDC typically have around two megabytes or more of total memory available for the Java platform, including both RAM and ROM. Target devices for CDC typically contain connectivity to a network, often a wireless one with a limited bandwidth. 2.1 C Virtual Machine CVM is a small-footprint virtual machine incorporating the latest in JVM technology, while remaining suitable for the embedded world. According to Sun, it is very portable, RTOS-aware, deterministic, and space-efficient. It allows devices to map Java threads directly to native threads, and can run Java classes out of ROM. It combines these embedded-friendly features with advanced VM features such as a precise memory system, generational garbage collector, and fast Java synchronization. Finally, CVM supports all Java 2 Platform, version 1.3, JVM features and libraries for security, weak references, JNI, RMI, and JVMDI. The technical white paper introduces a set of features, which are claimed to make CDC suitable for small devices. These are collected in Table 1. In Section 4 we will take a deeper look at these features by running various tests in order to find out, how these features are fulfilled. 2.2 CDC Classes In general, CDC contains the minimal Java packages from Java 2 SE to build and run the JVM. These packages are: java.lang java.util java.net System classes. Underlying Java utilities. UDP Datagram and File I/O. java.io Java File I/O. java.text Minimal support for I18n.
5 23 Table 1 CDC features [3] Feature Improved memory system RTOS-aware Fast synchronization Preloaded classes Native threads Small memory footprint Efficient stack usage Clean shutdown and restart Pluggable architecture Description Incorporated exactness, small average GC pause times (generational GC algorithm), separation of JVM from the memory system and pluggable GCs. CDC is implemented in C, with very little Assembler. It includes a well-documented porting layer and multiple porting options leaving the porter only the bare minimum of porting work. Most of the synchronization operations are performed with just a few machine instructions, without consuming additional OS-level lock resources. Java classes can be ROMified resulting in better startup time and less fragmentation. Performs internal synchronization and GC correctly in presence of preemptive native threading. Memory footprint for classes is about 40 percent compared to Java 2 SE and around 17 percent compared to Personal Java. CVM features deterministic and reduced-footprint native stack usage, achieved by careful static analysis of the JVM code. All allocated memory is guaranteed to be freed and all threads are guaranteed to be stopped. CVM provides extensible and well-defined interfaces making it easy to add new features to CVM. java.security Minimal fine-grain security and encryption for object serialization It should be noted that CDC as well as the Foundation Profile make corrections to the Java 2 SE API library by removing all noncritical, deprecated APIs. 2.3 The Foundation Profile The Foundation Profile is a set of Java APIs that, together with the CDC, provides a complete application runtime environment for small devices. CVM is the engine for the Foundation Profile libraries. Typical implementations use a subset of the Java 2 SE platform, depending on the application area.
6 24 In general, the Foundation Profile contains the complete Java packages from Java 2 SE, except that the GUI dependencies on java.awt are removed. The basic packages from CDC are modified in the Foundation Profile as follows: java.lang java.util java.net Full java.lang.* Java 2 SE package support. Adds full Zip support and some utilities (e.g. Timer). Adds TCP/IP Socket and HTTP connections. java.io Full java.io.* Java 2 SE package support for Java I/O. java.text Full java.text.* Java 2 SE package support for I18n. java.security Adds code signing and certificates.
7 25 Table 2 Small device categories Operating System Java Environments Example devices Windows CE/Pocket PC Personal Java (CDC), proprietary JVMs Casio Cassiopeia E-125, HP Jornada 500 Series PalmOS J2ME CLCD Palm m505, Motorola Accompli 008 Linux Java 1.1, Java 2, CDC, Kaffe Compaq ipaq H3630, VTech Helio Others, e.g. and Nokia Symbian Personal Java, own clean-room implementations Nokia Communicator 9210, Psion Series 5mx 3 JAVA ON HANDHELD DEVICES Installing and running Java environment on handheld devices introduces problems in terms of the limitations of the devices. The main limitations that mainly relate to Java are the limited processing power, limited amount of Read Only Memory (ROM) and Random Access Memory (RAM) 3. Optionally, if graphical user interaction is considered, the small screen size and resolution, and alternative input methods, such as touchscreen, may pose some additional constraints to the Java environment and the applications running in it. The small devices can be divided, based on the operating system, roughly into four categories, which are shown in Table 2. Windows CE/Pocket PC devices usually use commercial JVM implementations or free Personal Java reference implementation from Sun. Personal Java will merge as Personal Profile on top of CDC under the J2ME family in the future. The problem so far is that Personal Java is based on Java 1.1, whereas CDC is based on Java 2 and has removed all deprecations. Palm devices running PalmOS are usually only able to run J2ME CLCD due to their limiting processing power and amount of memory. Linux offers the widest range for choosing Java environment. Compaq ipaq H3600 family is an example of a handheld Linux machine. In this machine it is possible to run both Java 1.1, Java 2 and Kaffe, which is a clean-room implementation of Java 1.1-compliant virtual machine. Sun Microsystems, Inc. has also demonstrated CDC-port for ipaq Linux. Unfortunately we do not have this port available for testing yet. The fourth category consists of devices that run either some own clean-room implementation or some implementation of Personal Java specification. 3 High-end small devices usually have 64MB of RAM and 16-32MB of ROM, on which the operating system and pre-installed application software are installed.
8 26 4 COMPARING CDC TO JAVA STANDARD EDITION CDC is meant to be a scaled-down version of Java 2 environment. Java 1.1 on the other hand is mostly supported Java environment on the handheld devices, because almost all the implementations follow either Java 1.1 directly or implement the PersonalJavaspecification. In this section we introduce a set of test cases which are used to test the CDC and compare it to Java 2 and 1.1 standard editions. We inspect the static and dynamic footprint of the JVMs, performance and compliance. In the tests we don t take the Swing-classes into account, because they are not supported implicitly in Java 1.1 and at all in CDC. Also, we run Java 2 in interpreter-mode, because JIT (Just-in-time) compilation is not available in Java 1.1 and CDC. We tried to select the tests so that they reflect the key features of Java language as much as possible in terms of performance. To compare the performance aspects between Java 2, Java 1.1 and CDC, we implemented a test set, which consists of the following test cases: 1. Object creation 2. Threads and synchronization 3. Garbage collector performance and pause times 4. I/O (Input/Output streams) 5. Java Collection classes 6. Real application In object creation test case we simply measure the time needed to create a large number of objects. Threads and synchronization test case creates a set of objects, each making a method call to a synchronized method. Java reflection test case measures the overhead introduced when creating objects using Java reflection API instead of creating an object traditionally. In garbage collector s case we only study the GC algorithm used in CDC, because the tracing support in CDC could not provide us with the timestamp information so that we could have inspected the pause times in detail. I/O test case measures the time to read and write data, with different kinds of streams, to the disk. In Java Collection classes test case we compare the performance of Java Collections classes. Finally, the real application test case tests the collective effect of the functions from all of the previous test cases, excluding the Java reflection. In this test case we run a Java-based agent platform called MicroFIPA-OS [10]. The test environment we used in our tests is specified in Table Static footprint Static footprints are measured on both JVM executables and class libraries. Java 1.1 and 2 include AWT GUI libraries, but not Swing-libraries, which in CDC are not included. This should be taken into account when comparing class libraries
9 27 Table 3 Environment used in tests Hardware Model Processor Memory Toshiba Portégé 7140CT Laptop Intel Pentium III (500MHz) 192 Mb Software OS Linux Java2SE Java 2 SE Version Java 1.1 SE Java 1.1 SE Version CDC J2ME Version J2ME CDC 1.0 footprints. In CDC s case the size of the CVM build depends on the compilation options. In our measurements the CVM has the Foundation Profile support built in. Without Foundation the size of the executable is about 400 Kb smaller. The results are shown in Figure 2. CDC provides an interesting feature of allowing Java classes to be compiled in compact form using CodeCompact tool that comes with the distribution. The result object file from this tool can then be statically linked with the JVM as preloaded class. We did not test this feature though. JVM Executable Footprint Class Library Footprints Bytes Bytes Java 1.1 Java 2 CDC Java environment 0 Java 1.1 Java 2 CDC Figure 2 Static footprint sizes 4.2 Dynamic footprint Dynamic footprint sizes are measured by running the real application, MicroFIPA- OS, and acquiring the allocated memory from Linux process table. Therefore, the
10 28 measurement includes allocated memory for both JVM and the application s classes. The results are shown in Figure 3. Java 1.1 clearly seems to have the smallest footprint, whereas Java 2 with green threads is quite equal to CDC, about 6Mb. But being so high, having more than one JVM running on a handheld device seems unrealistic. Dynamic Footprints Bytes Java 1.1 Java 2 green Java 2 native CDC Java environment Figure 3 Dynamic footprint sizes of MicroFIPA-OS 4.3 Performance Caffeine Benchmarks. CaffeineMark [7] is a benchmark program, which measures the performance of the execution of Java programs. The CaffeineMark uses 9 subtests to measure various aspects of Java virtual machine performance. In Figure 4 the CaffeineMark 3.0 benchmark results for the target devices are presented. It should be noted that because CDC does not support GUIs, we used embedded-mode of the CaffeineMark, which does not measure the performance of Java graphical libraries. The results show that Java 1.1 and Java 2 are superior over CDC. This is quite surprising, because we believed that CDC would be as performative as Java 2. Furthermore, we found out that there was no single subtest in CaffeineMark that performed much poorer than the others thus being able to drag the overall score down; instead, every test performed equally poorly as compared to the subtest results of Java 1.1 and 2. The reason might be in some caching scheme that could be applied in Java 1.1 and 2, but not in CDC. However, we could not verify this and the real reason for performance difference remains unsolved Object creation. In object creation test case we create objects in a loop and measure the time spent on creating the objects. To get a better understanding on the scalability, we use run the loop for 1000, , and times. The
11 29 CaffeineMark 3.0 Benchmarks ,7 901,5 Benchmark ,3 Java 1.1 Java 2 CDC Java environment Figure 4 CaffeineMark 3.0 Benchmark results. Larger bar implies better results results are shown in Figure 5. All the measurements represent an average of ten test rounds. It should also be noted that the x-axis is not linear. It is quite surprising to see that CDC performs worse than Java 1.1 and 2. With smaller amounts of objects the performances are quite equal, but with larger amounts the CDC starts to become slower than the others. It must be kept in mind though that in handheld devices we cannot even create large amounts of objects because of the limitations in available memory, but in general, CDC does not seem scale well with large loads of objects. One reason could be that CDC is optimized for small amounts of objects. It might also be that the reference implementation from Sun simply is not optimized at all Threads and synchronization. Threads and synchronization test case inspects the effectiveness of handling large amounts of threads and synchronization between them. In this case we create 10, 100 and 1000 threads and let them all call a shared synchronized method. CDC supports only native threads, i.e. the Java threads are mapped directly to threads provided by the operating system. However, in Java 2 there is a possibility to choose from native and green threads. Green threads are scheduled by the JVM itself, and thus are more lightweight in terms of overhead in creation and context switching. Therefore, in this test case we inspected both native and green threads in Java 2. Java 1.1 only supports green threads. The results are shown in Figure 6. As in the previous test case, these results are averages of ten test rounds and in the figure the x-axis is not linear. The results show that native threads in Java 2 cannot match the performance of the native threads in CDC and green threads in Java 1.1. This is understandable, but also encouraging for the CDC, because its implementation of threading seems to work a lot faster than in Java 2. This is inline with the claims that Sun makes in their specifications.
12 30 Object creation Time (ms) Java 1.1 Java 2 CDC Nbr. of objects Figure 5 Object creation times Threads and synchronization Time (ms) Java 1.1 Java 2 green Java 2 native CDC Nbr. of threads Figure 6 Thread execution and synchronization measurements Garbage collector performance and pause times. Garbage collection has been critizised for two reasons: low throughput and high latency. In other words, collection will either slow down the end-to-end performance of their systems, or induce long collection pauses, or both. Generational garbage collection technique can address both performance problems. They split the heap into generations according to object age. Concentrating collection activity on the young generation increases throughput, because (in most programs) young objects are more likely to be garbage, so more free space is recovered per unit of collection work. Since the young generation is
13 typically small relative to the total heap size, young-generation collections are usually brief, addressing the latency concern. However, objects that survive a sufficiently large number of young-generation collections are considered long-lived, and are promoted into an older generation. Even though the older generation is typically larger, it will eventually be filled and require collection. Old-generation collection has latency and throughput similar to full-heap collection; thus, generational techniques actually only postpone, but do not solve, the problem [8]. CDC supports generational GC algorithm by default. We believe that the generational GC is chosen because it fits into the real-time environments because it is interruptible and can therefore guarantee a upper bound for GC pause time. However, the use of generational GC techniques in embedded devices has been critizised to some extent [9]. First of all, it has a bigger footprint than simple mark-and-sweep collectors. Also, because it is a copying collector in its nature, meaning that the Java heap is compacted once in awhile to defragment the heap, there has to be two logical heaps. It should be noted though that simple reference counting has its disadvantages too in this context, because it requires that every instance of a class includes a reference field. Thus, it could be summarized that generational garbage collectors work best in real-time environments and when the amount of runtime objects is large, whereas simple reference counting suits better to environments, where there are only a few runtime objects and real-time requirements do not have to be met. We believe that this is the reason why CDC supports pluggable garbage collectors, so that if the default one does not fit in target application environment, a more suitable GC algorithm can be used instead I/O (Input/Output streams). In this test case we measure the performance of three different streams: FileReader, DataInputStream and ObjectStream. With FileReader we read an two-kilobyte ASCII file from the disk. The same file is read also using DataInputStream. The difference between these two is that with FileReader we read Java Strings whereas with DataInputStream we are dealing with bytes. ObjectStream is used for testing the Java serialization by first writing object to and then reading them from a ObjectStream. The results are shown in Figure 7. All the test results are averages of ten test rounds. There are a few points to raise about the results. First of all, DataInputStream performed poorly because reading was not buffered. This explains the general performance gap between FileReader and DataInputStream. Secondly, in FileReader and ObjectStreams CDC performed well as compared to Java 1.1 and 2. We believe that the reason for this is that in CDC both FileReader and ObjectStreams use rewritten native code. This seemed to especially boost the performance in ObjectStreams, while the differencies in FileReader and DataInputStream are not significant Java Collections. Java Collections are tested using three-step approach. The results are shown in Figure 8. First we create a large LinkedList and fill it with Integer-objects. This is labelled in the figure as Creation. Secondly, we iterate the 31
14 32 Input/Ouput Streams ,2 Time (ms) ,3 19,9 15,5 12,4 5,5 3,7 4,1 2,6 Java 1.1 Java 2 CDC Java environment FileReader DataStream ObjectStream Figure 7 Java I/O measurements list through using Iterator interface and remove every second element from the list. This is labelled as Iteration in the figure. Finally, we sort the list into ascending order by converting it first to a array of objects and then using Arrays.sort()-method. This is labelled as Sorting in the figure. It should be noted that because Java 1.1 does not have the Collections classes built in, we used an external Collections-package for Java 1.1. The results are shown in Figure 8. These test results are averages of ten test rounds. The results show that Java 1.1 beats both Java 2 and CDC in every case, although the most significant difference is in the object creation phase, which we already inspected in Section CDC performs most poorly in every case, but the difference in the cases of iteration and sorting is not significant as compared to Java 1.1 and Real application. In the final test we run a MicroFIPA-OS agent platform, which is a middleware for running software agents on handheld devices [10]. Because it does not require a GUI, it suits well for our testing purposes. The test case consists of starting up the agent platform, which involves creating a large number of objects, firing up multiple threads and using sockets. The results of this test case are shown in Figure 9. Again in this test case the results are averages of ten test rounds. It can be seen that when a real application utilizing all features that are tested separately, the performance gap shown in some test cases seem to even out. Although Java 1.1 is still the most performative, the differencies are not significant. 4.4 Compliance We found out that in our tests CDC API was compliant with Java 2 API. The only exception is the lack of GUI classes. If a GUI is needed in CDC, another profile
15 33 Java Collections ,2 Time (ms) , ,9 51,9 39,6 20,2 46,1 23,7 Creation Iteration Sorting 10 0 Java 1.1 Java 2 CDC Java environment Figure 8 Performance of Java Collection classes MicroFIPA-OS Startup ,5 5537,8 5043, Time (ms) Java 1.1 Java 1.2 green Java 2 native CDC Java environment Figure 9 Performance of MicroFIPA-OS agent platform together with Foundation must be used, or the GUIs can be implemented in some other language allowing interaction between it and CDC code. Java 1.1 on the other hand is not upwards compliant with CDC meaning that in CDC it is possible to run Java 1.1 code, but not vice versa. For porting CDC code on to Java 1.1 the missing classes must be replaced with external class libraries. For instance, the Java Collections are available as a separate package for Java 1.1 providing the same API as in Java 2. The developer only needs to restructure the imports clauses in Java code and recompile.
16 34 5 ANALYSIS CDC turned out to be superior in footprint sizes as compared to Java 1.1 and 2. According to Sun the CDC is targeted to machines having around 2Mb of memory. We found out that with Foundation Profile compiled in, the footprint size of the CVM is about 2.4Mb. But the fact is that without Foundation Profile the CDC is quite useless. When we take CVM footprint together with the footprint of Foundation classes, we are not talking about 2Mb anymore. Furthermore, the GUI classes are not included. Although the target devices for CDC usually have 16Mb of ROM, we think that, with Foundation and some GUI library, consuming almost half of that amount to just have a Java environment on the device is not acceptable. After all, the Java environment being as a middleware is there only to allow applications to be run. Having said this we must of course remember that the implementation we used is the first implementation available, and cannot be considered as a final product. Therefore, we can expect optimizations on various aspects in further releases. Furthermore, all our experiments are based on running CDC on laptop Linux, which might not reflect the situation with for instance CDC on Compaq ipaq running Linux. Generally the claims that Sun makes about CDC hold pretty well. Threading and synchronization works really fast, remembering that the threads in CDC are native threads. Native threads in CDC are almost as fast as green threads in Java 1.1 and 2. However, one interesting point about native thread support is the justification for supporting them. It is well known that green threads are inherently faster to create and to change context, so why not support them in CDC? We believe that the use of native threads is well justified in multiprocessor environment, where each thread can be physically assigned to run on a separate processor thus having a real gain in performance. But in single processor environments, which the handheld devices currently are and we think will be in future also, having green threads would sound a more reasonable choice. I/O streams, especially object streams are really fast in CDC. Reading a file and reading/writing objects to an object stream is even faster than in Java 1.1. Object creation, especially when creating a large number of them, turned out to be slow in CDC. Speaking for CDC it must be noted that the amounts of objects we created in our test case is practically impossible in real handheld device due to the limited amount of memory. Pluggable garbage collector scheme is an advantage of CDC over the other Java environments. If the default GC algorithm does not suite the target application s requirements, the algorithm can be changed. What could be argued is the choice of generational GC algorithm as the default one. In the realtime environments it is justified, but in non-realtime environments a simpler algorithm might be better. Furthermore, simple reference counting is said to be more effective over the generational algorithm, when the amount of garbage is small. Software design for resource-constrained systems promotes the reuse of objects thus trying to avoid object creations, which turned out to be a heavy operation in Java, and especially CDC. Thus, with a good-designed application the amount of garbage should be low, and therefore a simple GC algorithm could be used.
17 6 CONCLUSION AND FUTURE WORK In this paper the CDC of J2ME was studied and its applicability to handheld devices was analysed by running several tests and comparing it with Java 1.1 and Java 2. The tests included measurements for static and dynamic footprints and performance in terms of object creation, threading and synchronization, I/O streams, Java Collections and a real application called MicroFIPA-OS. In addition we studied the garbage collection implementation in CDC. We found out that although there were some significant differencies in performance in some test cases, it seems that when running a real application, the performance differencies in separate test cases even out. Although CDC is designed to be run in handheld devices having limited amount of memory and CPU power, its performance is not any better than Java 2 or Java 1.1. What is good in CDC is the small total static footprint size as compared to Java 1.1 and Java 2. The big disadvantage is that the with CDC supplemented with Foundation Profile it is not possible to develop GUIs. We think that GUIs are essential method for user interaction especially in handheld devices, where the limited ways for user interaction basically rule out for instance the use of written text input. Without a point-and-click user interaction the use of a handheld device is not feasible. Thus, when a GUI is needed and Swing is not required, JDK 1.1 seems the best choice for handheld devices in terms of runtime performance. However, in the future there will be optimized releases of CDC, especially for real handheld devices, and additional profiles on top of CDC providing GUI classes. These will most probably make CDC the most appropriate Java environment for handheld devices. In the future we will port the CDC on to Compaq ipaq device and perform the tests in order to see, how the CDC performs in real device. 35
18 36 References [1] Sun Microsystems, Inc. PersonalJava Specification version 1.2a Available at: [2] Sun Microsystems, Inc. JSR J2ME[tm] Connected Device Configuration Specification - Final Release Available at: [3] Sun Microsystems, Inc. Connected Device Configuration (CDC) and the Foundation Profile. Technical Whitepaper Available at: [4] Sun Microsystems, Inc. Connected Device Configuration Reference Implementation Available at: [5] Insignia Solutions. Insignia - homepage Available at: enabled.htm. [6] NSICom. CrEme[tm] - The Java[tm] Enabler for Windows CE Available at: [7] Pendragon Software Corporation. CaffeineMark 3.0 homepage Available at [8] Detlefs David and Printezis Tony Generational Mostly-concurrent Garbage Collector. Sun Microsystems Research. Technical Report, TR Jun [9] Petit-Bianco Alexandre No Silver Bullet - Garbage Collection for Java in Embedded Sytems. Red Hat Embedded Documents (Cygnus). Technical Whitepaper. Jan Available at: nosb/. [10] University of Helsinki. MicroFIPA-OS - Small footprint extension to FIPA-OS Available at:
J2ME ARCHITECTURE AND RELATED EMBEDDED TECHNOLOGIES
J2ME ARCHITECTURE AND RELATED EMBEDDED TECHNOLOGIES Pradip Lamsal Abstract: Java 2 Platform Micro Edition (J2ME ), a flavour of Java architecture, is aimed at low memory consumer devices, typically less
More informationCM0256 Pervasive Computing
CM0256 Pervasive Computing Lecture 17 Software Development Approaches Tom Goodale t.r.goodale@cs.cardiff.ac.uk Lecture Outline In this lecture we: J2ME applications Palm. Device Limitations Limited Power
More informationFiji VM Safety Critical Java
Fiji VM Safety Critical Java Filip Pizlo, President Fiji Systems Inc. Introduction Java is a modern, portable programming language with wide-spread adoption. Goal: streamlining debugging and certification.
More informationCRUMPET. Creation of user-friendly mobile services personalised for tourism
Creation of user-friendly mobile services personalised for tourism Project Number: Project Title: Deliverable Type: CRUMPET, Creation of User Friendly Mobile Services Personalised for Tourism P CEC Deliverable
More informationDAY 3 J2ME March 2007 Aalborg University, Mobile Device Group Mobile Phone Programming
DAY 3 J2ME Mobile Phone Programming Module 2 Micro (J2ME) Overview Introduction J2ME architecture Introduction 1 J2ME Key Factors Portability: Write once run anywhere Security: Code runs within the confines
More informationJava On Steroids: Sun s High-Performance Java Implementation. History
Java On Steroids: Sun s High-Performance Java Implementation Urs Hölzle Lars Bak Steffen Grarup Robert Griesemer Srdjan Mitrovic Sun Microsystems History First Java implementations: interpreters compact
More informationJamaicaVM Java for Embedded Realtime Systems
JamaicaVM Java for Embedded Realtime Systems... bringing modern software development methods to safety critical applications Fridtjof Siebert, 25. Oktober 2001 1 Deeply embedded applications Examples:
More informationOverview of Java 2 Platform, Micro Edition (J2ME )
CHAPTER2 Overview of Java 2 Platform, Micro Edition (J2ME ) 2.1 Java 2 Platform Recognizing that one size does not fit all, Sun Microsystems has grouped Java technologies into three editions, each aimed
More informationPennBench: A Benchmark Suite for Embedded Java
WWC5 Austin, TX. Nov. 2002 PennBench: A Benchmark Suite for Embedded Java G. Chen, M. Kandemir, N. Vijaykrishnan, And M. J. Irwin Penn State University http://www.cse.psu.edu/~mdl Outline Introduction
More informationMobile Application Development. Introduction. Dr. Christelle Scharff Pace University, USA
Mobile Application Development Introduction Dr. Christelle Scharff cscharff@pace.edu Pace University, USA Objectives Getting an overview of the mobile phone market, its possibilities and weaknesses Providing
More informationNew Java performance developments: compilation and garbage collection
New Java performance developments: compilation and garbage collection Jeroen Borgers @jborgers #jfall17 Part 1: New in Java compilation Part 2: New in Java garbage collection 2 Part 1 New in Java compilation
More informationRequirements and Issues of V**s for Mobile Terminals
Requirements and Issues of V**s for Mobile Terminals Workshop on the Future of Virtual Execution Environments Armonk, NY, USA 15-17.09.2004 Kari Systä Nokia Research Center 1 NOKIA Presentation_Name.PPT
More informationA JVM Does What? Eva Andreasson Product Manager, Azul Systems
A JVM Does What? Eva Andreasson Product Manager, Azul Systems Presenter Eva Andreasson Innovator & Problem solver Implemented the Deterministic GC of JRockit Real Time Awarded patents on GC heuristics
More informationWho am I? Wireless Online Game Development for Mobile Device. What games can you make after this course? Are you take the right course?
Who am I? Wireless Online Game Development for Mobile Device Lo Chi Wing, Peter Lesson 1 Email: Peter@Peter-Lo.com I123-1-A@Peter Lo 2007 1 I123-1-A@Peter Lo 2007 2 Are you take the right course? This
More informationDAY 3 J2ME Aalborg University, Mobile Device Group. Mobile. Mobile Phone Programming
DAY 3 J2ME Mobile Phone Programming Java 2 Micro Edition (J2ME) Overview Introduction J2ME architecture MIDlets Application development Introduction J2ME Key Factors Portability: Write once run anywhere
More informationJava Performance Tuning
443 North Clark St, Suite 350 Chicago, IL 60654 Phone: (312) 229-1727 Java Performance Tuning This white paper presents the basics of Java Performance Tuning and its preferred values for large deployments
More informationLesson 5: Software for embedding in System- Part 2
Lesson 5: Software for embedding in System- Part 2 Device drivers, Device manager, OS, RTOS and Software tools 1 Outline Device drivers Device manager Multitasking using an operating system (OS) and Real
More informationCRUMPET. CReation of User-friendly Mobile services PErsonalised for Tourism. Stefan Poslad, Heimo Laamanen, Sasu Tarkoma
CRUMPET CReation of User-friendly Mobile services PErsonalised for Tourism Stefan Poslad, Heimo Laamanen, Sasu Tarkoma Co-ordinator: stefan.poslad@elec.qmul.ac.uk More at http://www.ist-crumpet.org CRUMPET
More informationTowards Introducing Code Mobility on J2ME. Laurentiu Lucian Petrea and Dan Grigoras Computer Science Department UCC Cork, Ireland
Towards Introducing Code Mobility on J2ME Laurentiu Lucian Petrea and Dan Grigoras Computer Science Department UCC Cork, Ireland www.mccg.ucc.ie Mobile Ad Hoc Networks Heterogeneous mobile devices No fixed
More informationOperating- System Structures
Operating- System Structures 2 CHAPTER Practice Exercises 2.1 What is the purpose of system calls? Answer: System calls allow user-level processes to request services of the operating system. 2.2 What
More informationChapter 3 - Memory Management
Chapter 3 - Memory Management Luis Tarrataca luis.tarrataca@gmail.com CEFET-RJ L. Tarrataca Chapter 3 - Memory Management 1 / 222 1 A Memory Abstraction: Address Spaces The Notion of an Address Space Swapping
More informationImperative model of computation
12 Imperative model of computation Peter Marwedel TU Dortmund, Informatik 12 Graphics: Alexandra Nolte, Gesine Marwedel, 2003 2010/10/28 These slides use Microsoft clip arts. Microsoft copyright restrictions
More informationSeminar report Java Submitted in partial fulfillment of the requirement for the award of degree Of CSE
A Seminar report On Java Submitted in partial fulfillment of the requirement for the award of degree Of CSE SUBMITTED TO: www.studymafia.org SUBMITTED BY: www.studymafia.org 1 Acknowledgement I would like
More informationChapter 8 & Chapter 9 Main Memory & Virtual Memory
Chapter 8 & Chapter 9 Main Memory & Virtual Memory 1. Various ways of organizing memory hardware. 2. Memory-management techniques: 1. Paging 2. Segmentation. Introduction Memory consists of a large array
More informationJava & Coherence Simon Cook - Sales Consultant, FMW for Financial Services
Java & Coherence Simon Cook - Sales Consultant, FMW for Financial Services with help from Adrian Nakon - CMC Markets & Andrew Wilson - RBS 1 Coherence Special Interest Group Meeting 1 st March 2012 Presentation
More information2011 Oracle Corporation and Affiliates. Do not re-distribute!
How to Write Low Latency Java Applications Charlie Hunt Java HotSpot VM Performance Lead Engineer Who is this guy? Charlie Hunt Lead JVM Performance Engineer at Oracle 12+ years of
More informationMobile Station Execution Environment (MExE( MExE) Developing web applications for PDAs and Cellphones. WAP (Wireless Application Protocol)
Developing web applications for PDAs and Cellphones Mobile Station Execution Environment (MExE( MExE) MExE is a standard for defining various levels of wireless communication These levels are called classmarks
More informationJava Jitters - The Effects of Java on Jitter in a Continuous Media Server
Introduction Java Jitters - The Effects of Java on Jitter in a Continuous Media Server Mark Claypool and Jonathan Tanner Computer Science Department, Worcester Polytechnic Institute {claypool,jtanner}@cs.wpi.edu
More informationInteraction of JVM with x86, Sparc and MIPS
Interaction of JVM with x86, Sparc and MIPS Sasikanth Avancha, Dipanjan Chakraborty, Dhiral Gada, Tapan Kamdar {savanc1, dchakr1, dgada1, kamdar}@cs.umbc.edu Department of Computer Science and Electrical
More informationPerformance of Non-Moving Garbage Collectors. Hans-J. Boehm HP Labs
Performance of Non-Moving Garbage Collectors Hans-J. Boehm HP Labs Why Use (Tracing) Garbage Collection to Reclaim Program Memory? Increasingly common Java, C#, Scheme, Python, ML,... gcc, w3m, emacs,
More informationDevice Technologies I J2ME & WinCE
Device Technologies I J2ME & WinCE Patrick J. Stockreisser p.j.stockreisser@cs.cardiff.ac.uk Lecture Outline In the lecture we will: Look at considerations needed to run applications on mobile or pervasive
More informationphoneme: High-performance, product-quality GPLv2 CDC + CLDC stacks Terrence Barr
phoneme: High-performance, product-quality GPLv2 CDC + CLDC stacks Terrence Barr Senior Technologist and Community Ambassador Java Mobile & Embedded Community Sun Microsystems 1 Platform Scalability and
More informationHigh Performance Managed Languages. Martin Thompson
High Performance Managed Languages Martin Thompson - @mjpt777 Really, what is your preferred platform for building HFT applications? Why do you build low-latency applications on a GC ed platform? Agenda
More informationDistributed Systems Operation System Support
Hajussüsteemid MTAT.08.009 Distributed Systems Operation System Support slides are adopted from: lecture: Operating System(OS) support (years 2016, 2017) book: Distributed Systems: Concepts and Design,
More informationOutline. Introduction to Java. What Is Java? History. Java 2 Platform. Java 2 Platform Standard Edition. Introduction Java 2 Platform
Outline Introduction to Java Introduction Java 2 Platform CS 3300 Object-Oriented Concepts Introduction to Java 2 What Is Java? History Characteristics of Java History James Gosling at Sun Microsystems
More informationJAVA PERFORMANCE. PR SW2 S18 Dr. Prähofer DI Leopoldseder
JAVA PERFORMANCE PR SW2 S18 Dr. Prähofer DI Leopoldseder OUTLINE 1. What is performance? 1. Benchmarking 2. What is Java performance? 1. Interpreter vs JIT 3. Tools to measure performance 4. Memory Performance
More informationHierarchical PLABs, CLABs, TLABs in Hotspot
Hierarchical s, CLABs, s in Hotspot Christoph M. Kirsch ck@cs.uni-salzburg.at Hannes Payer hpayer@cs.uni-salzburg.at Harald Röck hroeck@cs.uni-salzburg.at Abstract Thread-local allocation buffers (s) are
More informationJVM Memory Model and GC
JVM Memory Model and GC Developer Community Support Fairoz Matte Principle Member Of Technical Staff Java Platform Sustaining Engineering, Copyright 2015, Oracle and/or its affiliates. All rights reserved.
More informationHeap Management. Heap Allocation
Heap Management Heap Allocation A very flexible storage allocation mechanism is heap allocation. Any number of data objects can be allocated and freed in a memory pool, called a heap. Heap allocation is
More informationGeneration scavenging: A non-disruptive high-performance storage reclamation algorithm By David Ungar
Generation scavenging: A non-disruptive high-performance storage reclamation algorithm By David Ungar Presented by Donald Nguyen February 9, 2009 1 / 13 Context The year was 1984... Microcomputers, interactive
More informationJavaME TAMZ. Department of Computer Science VŠB-Technical University of Ostrava
TAMZ 1 Contact Information Office: A-1007 Address: Dept. of Computer Science, FEECS 17. listopadu 15 708 33 Ostrava-Poruba Phone: +420 59 699 4219 E-mail: pavel.moravec@vsb.cz Web: http://wiki.cs.vsb.cz/index.php/moravec/cz
More informationJava Application Performance Tuning for AMD EPYC Processors
Java Application Performance Tuning for AMD EPYC Processors Publication # 56245 Revision: 0.70 Issue Date: January 2018 Advanced Micro Devices 2018 Advanced Micro Devices, Inc. All rights reserved. The
More informationJaguar: Enabling Efficient Communication and I/O in Java
Jaguar: Enabling Efficient Communication and I/O in Java Matt Welsh and David Culler UC Berkeley Presented by David Hovemeyer Outline ' Motivation ' How it works ' Code mappings ' External objects ' Pre
More informationMemory management has always involved tradeoffs between numerous optimization possibilities: Schemes to manage problem fall into roughly two camps
Garbage Collection Garbage collection makes memory management easier for programmers by automatically reclaiming unused memory. The garbage collector in the CLR makes tradeoffs to assure reasonable performance
More informationThe Garbage-First Garbage Collector
The Garbage-First Garbage Collector Tony Printezis, Sun Microsystems Paul Ciciora, Chicago Board Options Exchange #TS-9 Trademarks And Abbreviations (to get them out of the way...) Java Platform, Standard
More informationThe Impact of a Real-Time JVM on Middleware Performance: Lessons Learned from Implementing DDS on IBM s J9
The Impact of a Real-Time JVM on Middleware Performance: Lessons Learned from Implementing DDS on IBM s J9 Ken Brophy, Senior Applications Engineer, RTI Rick Warren, Lead Software Engineer, RTI Agenda
More informationCS 326: Operating Systems. Process Execution. Lecture 5
CS 326: Operating Systems Process Execution Lecture 5 Today s Schedule Process Creation Threads Limited Direct Execution Basic Scheduling 2/5/18 CS 326: Operating Systems 2 Today s Schedule Process Creation
More informationMEMORY MANAGEMENT HEAP, STACK AND GARBAGE COLLECTION
MEMORY MANAGEMENT HEAP, STACK AND GARBAGE COLLECTION 2 1. What is the Heap Size: 2 2. What is Garbage Collection: 3 3. How are Java objects stored in memory? 3 4. What is the difference between stack and
More informationJava Without the Jitter
TECHNOLOGY WHITE PAPER Achieving Ultra-Low Latency Table of Contents Executive Summary... 3 Introduction... 4 Why Java Pauses Can t Be Tuned Away.... 5 Modern Servers Have Huge Capacities Why Hasn t Latency
More informationThe Z Garbage Collector Low Latency GC for OpenJDK
The Z Garbage Collector Low Latency GC for OpenJDK Per Lidén & Stefan Karlsson HotSpot Garbage Collection Team Jfokus VM Tech Summit 2018 Safe Harbor Statement The following is intended to outline our
More informationSistemi in Tempo Reale
Laurea Specialistica in Ingegneria dell'automazione Sistemi in Tempo Reale Giuseppe Lipari Introduzione alla concorrenza Fundamentals Algorithm: It is the logical procedure to solve a certain problem It
More informationJava 2 Platform, Micro Edition
Java 2 Platform, Micro Edition ArchitectureOverview Jon Courtney Senior Staff Engineer Sun Microsystems JavaOne203 Sesion316 Overall Presentation Goal Learnaboutthearchitectural features ofthejava 2Platform,MicroEdition(J2ME
More informationBuilding Robust Embedded Software
Building Robust Embedded Software by Lars Bak, OOVM A/S Demands of the Embedded Industy Increased reliability Low cost -> resource constraints Dynamic software updates in the field Real-time capabilities
More informationGarbage-First Garbage Collection by David Detlefs, Christine Flood, Steve Heller & Tony Printezis. Presented by Edward Raff
Garbage-First Garbage Collection by David Detlefs, Christine Flood, Steve Heller & Tony Printezis Presented by Edward Raff Motivational Setup Java Enterprise World High end multiprocessor servers Large
More informationSABLEJIT: A Retargetable Just-In-Time Compiler for a Portable Virtual Machine p. 1
SABLEJIT: A Retargetable Just-In-Time Compiler for a Portable Virtual Machine David Bélanger dbelan2@cs.mcgill.ca Sable Research Group McGill University Montreal, QC January 28, 2004 SABLEJIT: A Retargetable
More informationJOP: A Java Optimized Processor for Embedded Real-Time Systems. Martin Schoeberl
JOP: A Java Optimized Processor for Embedded Real-Time Systems Martin Schoeberl JOP Research Targets Java processor Time-predictable architecture Small design Working solution (FPGA) JOP Overview 2 Overview
More informationJava performance - not so scary after all
Java performance - not so scary after all Holly Cummins IBM Hursley Labs 2009 IBM Corporation 2001 About me Joined IBM Began professional life writing event framework for WebSphere 2004 Moved to work on
More informationDeveloping Mobile Applications
Developing Mobile Applications J2ME Java 2 Micro Edition 1 Virtual machines portable apps virtual machine native apps operating system hardware 2 Java - important issues Symbolic language not a random
More informationGarbage Collection. Steven R. Bagley
Garbage Collection Steven R. Bagley Reference Counting Counts number of pointers to an Object deleted when the count hits zero Eager deleted as soon as it is finished with Problem: Circular references
More informationJava Performance Tuning and Optimization Student Guide
Java Performance Tuning and Optimization Student Guide D69518GC10 Edition 1.0 June 2011 D73450 Disclaimer This document contains proprietary information and is protected by copyright and other intellectual
More informationManaged runtimes & garbage collection. CSE 6341 Some slides by Kathryn McKinley
Managed runtimes & garbage collection CSE 6341 Some slides by Kathryn McKinley 1 Managed runtimes Advantages? Disadvantages? 2 Managed runtimes Advantages? Reliability Security Portability Performance?
More informationA comparison between the scheduling algorithms used in RTLinux and in VxWorks - both from a theoretical and a contextual view
A comparison between the scheduling algorithms used in RTLinux and in VxWorks - both from a theoretical and a contextual view Authors and Affiliation Oskar Hermansson and Stefan Holmer studying the third
More informationA new Mono GC. Paolo Molaro October 25, 2006
A new Mono GC Paolo Molaro lupus@novell.com October 25, 2006 Current GC: why Boehm Ported to the major architectures and systems Featurefull Very easy to integrate Handles managed pointers in unmanaged
More information10 Steps to Virtualization
AN INTEL COMPANY 10 Steps to Virtualization WHEN IT MATTERS, IT RUNS ON WIND RIVER EXECUTIVE SUMMARY Virtualization the creation of multiple virtual machines (VMs) on a single piece of hardware, where
More informationReal-time & Embedded Systems Workshop July 2007 Building Successful Real-time Distributed Systems in Java
Real-time & Embedded Systems Workshop July 2007 Building Successful Real-time Distributed Systems in Java Andrew Foster Product Manager PrismTech Corporation The Case for Java in Enterprise Real-Time Systems
More informationManaged runtimes & garbage collection
Managed runtimes Advantages? Managed runtimes & garbage collection CSE 631 Some slides by Kathryn McKinley Disadvantages? 1 2 Managed runtimes Portability (& performance) Advantages? Reliability Security
More informationWhat s in a traditional process? Concurrency/Parallelism. What s needed? CSE 451: Operating Systems Autumn 2012
What s in a traditional process? CSE 451: Operating Systems Autumn 2012 Ed Lazowska lazowska @cs.washi ngton.edu Allen Center 570 A process consists of (at least): An, containing the code (instructions)
More informationThe Z Garbage Collector An Introduction
The Z Garbage Collector An Introduction Per Lidén & Stefan Karlsson HotSpot Garbage Collection Team FOSDEM 2018 Safe Harbor Statement The following is intended to outline our general product direction.
More informationSCADA systems development on mobile device platform Java Client/Server model and localization enhancement
SCADA systems development on mobile device platform Java Client/Server model and localization enhancement ONDŘEJ KREJCAR, JINDŘICH ČERNOHORSKÝ Department Measurement and Control VSB Technical University
More informationWindows Java address space
Windows Java address space This article applies to the IBM 32-bit SDK and Runtime Environment for Windows, Java2 Technology Edition. It explains how the process space for Java is divided and explores a
More informationJava Internals. Frank Yellin Tim Lindholm JavaSoft
Java Internals Frank Yellin Tim Lindholm JavaSoft About This Talk The JavaSoft implementation of the Java Virtual Machine (JDK 1.0.2) Some companies have tweaked our implementation Alternative implementations
More informationI, J A[I][J] / /4 8000/ I, J A(J, I) Chapter 5 Solutions S-3.
5 Solutions Chapter 5 Solutions S-3 5.1 5.1.1 4 5.1.2 I, J 5.1.3 A[I][J] 5.1.4 3596 8 800/4 2 8 8/4 8000/4 5.1.5 I, J 5.1.6 A(J, I) 5.2 5.2.1 Word Address Binary Address Tag Index Hit/Miss 5.2.2 3 0000
More informationThe Fundamentals of JVM Tuning
The Fundamentals of JVM Tuning Charlie Hunt Architect, Performance Engineering Salesforce.com sfdc_ppt_corp_template_01_01_2012.ppt In a Nutshell What you need to know about a modern JVM to be effective
More informationJava Garbage Collector Performance Measurements
WDS'09 Proceedings of Contributed Papers, Part I, 34 40, 2009. ISBN 978-80-7378-101-9 MATFYZPRESS Java Garbage Collector Performance Measurements P. Libič and P. Tůma Charles University, Faculty of Mathematics
More informationSoftware Development & Education Center. Java Platform, Micro Edition. (Mobile Java)
Software Development & Education Center Java Platform, Micro Edition (Mobile Java) Detailed Curriculum UNIT 1: Introduction Understanding J2ME Configurations Connected Device Configuration Connected, Limited
More informationSummary: Open Questions:
Summary: The paper proposes an new parallelization technique, which provides dynamic runtime parallelization of loops from binary single-thread programs with minimal architectural change. The realization
More informationLast week, David Terei lectured about the compilation pipeline which is responsible for producing the executable binaries of the Haskell code you
Last week, David Terei lectured about the compilation pipeline which is responsible for producing the executable binaries of the Haskell code you actually want to run. Today, we are going to look at an
More informationIntroduction to Java Programming
Introduction to Java Programming Lecture 1 CGS 3416 Spring 2017 1/9/2017 Main Components of a computer CPU - Central Processing Unit: The brain of the computer ISA - Instruction Set Architecture: the specific
More informationOutline Background Jaluna-1 Presentation Jaluna-2 Presentation Overview Use Cases Architecture Features Copyright Jaluna SA. All rights reserved
C5 Micro-Kernel: Real-Time Services for Embedded and Linux Systems Copyright 2003- Jaluna SA. All rights reserved. JL/TR-03-31.0.1 1 Outline Background Jaluna-1 Presentation Jaluna-2 Presentation Overview
More informationRuntime. The optimized program is ready to run What sorts of facilities are available at runtime
Runtime The optimized program is ready to run What sorts of facilities are available at runtime Compiler Passes Analysis of input program (front-end) character stream Lexical Analysis token stream Syntactic
More informationWhat s in a process?
CSE 451: Operating Systems Winter 2015 Module 5 Threads Mark Zbikowski mzbik@cs.washington.edu Allen Center 476 2013 Gribble, Lazowska, Levy, Zahorjan What s in a process? A process consists of (at least):
More informationAlgorithms for Dynamic Memory Management (236780) Lecture 4. Lecturer: Erez Petrank
Algorithms for Dynamic Memory Management (236780) Lecture 4 Lecturer: Erez Petrank!1 March 24, 2014 Topics last week The Copying Garbage Collector algorithm: Basics Cheney s collector Additional issues:
More informationOperating System Performance and Large Servers 1
Operating System Performance and Large Servers 1 Hyuck Yoo and Keng-Tai Ko Sun Microsystems, Inc. Mountain View, CA 94043 Abstract Servers are an essential part of today's computing environments. High
More informationRunning class Timing on Java HotSpot VM, 1
Compiler construction 2009 Lecture 3. A first look at optimization: Peephole optimization. A simple example A Java class public class A { public static int f (int x) { int r = 3; int s = r + 5; return
More informationVirtualizing JBoss Enterprise Middleware with Azul
Virtualizing JBoss Enterprise Middleware with Azul Shyam Pillalamarri VP Engineering, Azul Systems Stephen Hess Sr. Director, Product Management, Red Hat June 25, 2010 Agenda Java Virtualization Current
More informationKodewerk. Java Performance Services. The War on Latency. Reducing Dead Time Kirk Pepperdine Principle Kodewerk Ltd.
Kodewerk tm Java Performance Services The War on Latency Reducing Dead Time Kirk Pepperdine Principle Kodewerk Ltd. Me Work as a performance tuning freelancer Nominated Sun Java Champion www.kodewerk.com
More informationA New Approach to Determining the Time-Stamping Counter's Overhead on the Pentium Pro Processors *
A New Approach to Determining the Time-Stamping Counter's Overhead on the Pentium Pro Processors * Hsin-Ta Chiao and Shyan-Ming Yuan Department of Computer and Information Science National Chiao Tung University
More informationJava Embedded on ARM
Java Embedded on ARM The Embedded Market Evolving Rapidly Internet of Things 2.3B Internet Users Cloud for Embedded Devices Med-Large Embedded Multi-function Devices Enterprise Data and Applications Up
More informationThe Z Garbage Collector Scalable Low-Latency GC in JDK 11
The Z Garbage Collector Scalable Low-Latency GC in JDK 11 Per Lidén (@perliden) Consulting Member of Technical Staff Java Platform Group, Oracle October 24, 2018 Safe Harbor Statement The following is
More informationNG2C: Pretenuring Garbage Collection with Dynamic Generations for HotSpot Big Data Applications
NG2C: Pretenuring Garbage Collection with Dynamic Generations for HotSpot Big Data Applications Rodrigo Bruno Luis Picciochi Oliveira Paulo Ferreira 03-160447 Tomokazu HIGUCHI Paper Information Published
More informationInformation Collection and Survey Infrastructure, APIs, and Software Tools for Agent-based Systems (An Overview of JADE)
Course Number: SENG 609.22 Session: Fall, 2003 Document Name: Infrastructure, APIs, and Software tools for agent-based system (An Overview of JADE) Course Name: Agent-based Software Engineering Department:
More informationMerge Sort Quicksort 9 Abstract Windowing Toolkit & Swing Abstract Windowing Toolkit (AWT) vs. Swing AWT GUI Components Layout Managers Swing GUI
COURSE TITLE :Introduction to Programming 2 COURSE PREREQUISITE :Introduction to Programming 1 COURSE DURATION :16 weeks (3 hours/week) COURSE METHODOLOGY:Combination of lecture and laboratory exercises
More informationJava Performance: The Definitive Guide
Java Performance: The Definitive Guide Scott Oaks Beijing Cambridge Farnham Kbln Sebastopol Tokyo O'REILLY Table of Contents Preface ix 1. Introduction 1 A Brief Outline 2 Platforms and Conventions 2 JVM
More informationJava Performance Tuning From A Garbage Collection Perspective. Nagendra Nagarajayya MDE
Java Performance Tuning From A Garbage Collection Perspective Nagendra Nagarajayya MDE Agenda Introduction To Garbage Collection Performance Problems Due To Garbage Collection Performance Tuning Manual
More informationPerformance Best Practices Paper for IBM Tivoli Directory Integrator v6.1 and v6.1.1
Performance Best Practices Paper for IBM Tivoli Directory Integrator v6.1 and v6.1.1 version 1.0 July, 2007 Table of Contents 1. Introduction...3 2. Best practices...3 2.1 Preparing the solution environment...3
More informationUsing Java for Scientific Computing. Mark Bul EPCC, University of Edinburgh
Using Java for Scientific Computing Mark Bul EPCC, University of Edinburgh markb@epcc.ed.ac.uk Java and Scientific Computing? Benefits of Java for Scientific Computing Portability Network centricity Software
More informationAcknowledgements These slides are based on Kathryn McKinley s slides on garbage collection as well as E Christopher Lewis s slides
Garbage Collection Last time Compiling Object-Oriented Languages Today Motivation behind garbage collection Garbage collection basics Garbage collection performance Specific example of using GC in C++
More informationOperating Systems Design Exam 2 Review: Spring 2011
Operating Systems Design Exam 2 Review: Spring 2011 Paul Krzyzanowski pxk@cs.rutgers.edu 1 Question 1 CPU utilization tends to be lower when: a. There are more processes in memory. b. There are fewer processes
More information1. What is Jav a? simple
1. What is Jav a? Thanks to Java is a new programming language developed at Sun under the direction of James Gosling. As far as possible it is based on concepts from C, Objective C and C++. Java is interpreted
More informationLast class: OS and Architecture. OS and Computer Architecture
Last class: OS and Architecture OS and Computer Architecture OS Service Protection Interrupts System Calls IO Scheduling Synchronization Virtual Memory Hardware Support Kernel/User Mode Protected Instructions
More information