DOCSLIB.ORG

Design and Analysis of a Scala Benchmark Suite for the Java Virtual Machine

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Design and Analysis of a Scala Benchmark Suite for the Java Virtual Machine Design and Analysis of a Scala Benchmark Suite for the Java Virtual Machine Entwurf und Analyse einer Scala Benchmark Suite für die Java Virtual Machine Zur Erlangung des akademischen Grades Doktor-Ingenieur (Dr.-Ing.) genehmigte Dissertation von Diplom-Mathematiker Andreas Sewe aus Twistringen, Deutschland April 2013 — Darmstadt — D 17 Fachbereich Informatik Fachgebiet Softwaretechnik Design and Analysis of a Scala Benchmark Suite for the Java Virtual Machine Entwurf und Analyse einer Scala Benchmark Suite für die Java Virtual Machine Genehmigte Dissertation von Diplom-Mathematiker Andreas Sewe aus Twistrin- gen, Deutschland 1. Gutachten: Prof. Dr.-Ing. Ermira Mezini 2. Gutachten: Prof. Richard E. Jones Tag der Einreichung: 17. August 2012 Tag der Prüfung: 29. Oktober 2012 Darmstadt — D 17 For Bettina Academic Résumé November 2007 – October 2012 Doctoral studies at the chair of Prof. Dr.-Ing. Er- mira Mezini, Fachgebiet Softwaretechnik, Fachbereich Informatik, Techni- sche Universität Darmstadt October 2001 – October 2007 Studies in mathematics with a special focus on com- puter science (Mathematik mit Schwerpunkt Informatik) at Technische Uni- versität Darmstadt, finishing with a degree of Diplom-Mathematiker (Dipl.- Math.) iii Acknowledgements First and foremost, I would like to thank Mira Mezini, my thesis supervisor, for pro- viding me with the opportunity and freedom to pursue my research, as condensed into the thesis you now hold in your hands. Her experience and her insights did much to improve my research as did her invaluable ability to ask the right questions at the right time. I would also like to thank Richard Jones for taking the time to act as secondary reviewer of this thesis. Both their efforts are greatly appreciated. Time and again, I am astonished by the number of collaborators and co-authors whom I have worked with during these past five years: Mehmet Ak¸sit,Sami Al- souri, Danilo Ansaloni, Remko Bijker, Walter Binder, Christoph Bockisch, Eric Bodden, Anis Charfi, Michael Eichberg, Samuel Z. Guyer, Kardelen Hatun, Mo- hamed Jmaiel, Jannik Jochem, Slim Kallel, Stefan Katzenbeisser, Lukáš Marek, Mira Mezini, Ralf Mitschke, Philippe Moret, Hela Oueslati, Nathan Ricci, Aibek Sarimbekov, Martin Schoeberl, Jan Sinschek, Éric Tanter, Petr Tuma,˚ Zhengwei Qi, Alex Villazón, Dingwen Yuan, Martin Zandberg, and Yudi Zheng. Others whom I have worked—albeit not written a paper—with are several talented and enthusiastic students: Erik Brangs, Pascal Flach, Felix Kerger, and Alexander Nickol; their work influenced and improved mine in various ways. Still others have helped me realize the vision of a Scala benchmark suite for the Java Virtual Machine by graciously providing help with the suite’s various pro- grams, the programs’ input data, or both: Joa Ebert, Patrik Nordwall, Daniel Ram- age, Bill Venners, Tim Vieira, Eugene Yokota, and the late Sam Roweis. I am also deeply grateful to the DaCapo group for providing such an excellent foundation on which to build my Scala benchmark suite. Of all the aforementioned, there are few to which I want to express my thanks in particular: Christoph Bockisch and everyone at the Dynamic Analysis group of the University of Lugano. Together with Michael Haupt, my colleague Christoph exposed me to the wonderful world of virtual machines in general and Jikes RVM in particular. He also supported me not only during my Diplom thesis and my first year at the Software Technology group, but also after he left us for the Netherlands, to assume a position as assistant professor at the Universeit Twente. Aibek, Danilo, and Walter from the University of Lugano helped my tremendously in developing and refining many of the tools needed for the numerous experiments conducted as part of this thesis. Moreover, they made me feel very welcome on my visit to what may be the most beautiful part of Switzerland. v Here at the Software Technology group, further thanks go to my fellow PhD can- didates and post-docs for inspiring discussions, over lunch and beyond: Christoph Bockisch, Eric Bodden, Marcel Bruch, Tom Dinkelaker, Michael Eichberg, Vaidas Gasiunas, Ben Hermann, Sven Kloppenburg, Roman Knöll, Johannes Lerch, Ralf Mitschke, Martin Monperrus, Sebastian Proksch, Guido Salvaneschi, Lucas Sa- tabin, Thorsten Schäfer, Jan Sinschk, and Jurgen van Ham. The quality of my quantitative evaluations in particular benefited from dozens of discussions Ihad with Marcel. I would also like to thank Gudrun Harris for her unfailing support in dealing with all things administrative and for just making the Software Technology Group a very pleasant place to work at. And for her excellent baking, of course. My thanks also go to both the participants of and the reviewers for the Work- on-Progress session at the 2010 International Conference on the Principles and Practice of Programming in Java, held in Vienna; their suggestions and encourage- ment helped to turn a mere position paper into the thesis you now hold in your hands. My parents Renate and Kai-Udo Sewe provided valuable support throughout all my life. Finally, I am indebted to Bettina Birkmeier for her encouragement and patience—not to mention countless hours of proof-reading. Funding Parts of my work have been funded by AOSD-Europe, the European Network of Excellence on Aspect-Oriented Software Development.1 Other parts of the work have been funded by CASED, the Center for Advanced Security Research Darm- stadt,2 through LOEWE, the “Landes-Offensive zur Entwicklung Wissenschaftlich- ökonomischer Exzellenz.” 1 See http://www.aosd-europe.org/. 2 See http://www.cased.de/. vi Acknowledgements Abstract In the last decade, virtual machines (VMs) for high-level languages have become pervasive, as they promise both portability and high performance. However, these virtual machines were often designed to support just a single language well. The design of the Java Virtual Machine (JVM), for example, is heavily influenced by the Java programming language. Despite its current bias towards Java, in recent years the JVM in particular has been targeted by numerous new languages: Scala, Groovy, Clojure, and others. This trend has not been reflected in JVM research, though; all major benchmark suites for the JVM are still firmly focused on the Java language rather than onthe language ecosystem as a whole. This state of affairs threatens to perpetuate the bias towards Java, as JVM implementers strive to “make the common case fast.” But what is common for Java may be uncommon for other, popular languages. One of these other languages is Scala, a language with both object-oriented and functional features, whose popularity has grown tremendously since its first public appearance in 2003. What characteristics Scala programs have or have not in common with Java programs has been an open question, though. One contribution of this thesis is therefore the design of a Scala benchmark suite that is on par with modern, widely- accepted Java benchmark suites. Another contribution is the subsequent analysis of this suite and an in-depth, VM-independent comparison with the DaCapo 9.12 benchmark suite, the premier suite used in JVM research. The analysis shows that Scala programs exhibit not only a distinctive instruction mix but also object demographics close to those of the Scala language’s functional ancestors. This thesis furthermore shows that these differences can have a marked effect on the performance of Scala programs on modern high-performance JVMs. While JVMs exhibit remarkably similar performance on Java programs, the performance of Scala programs varies considerably, with the fastest JVM being more than three times faster than the slowest. vii Zusammenfassung Aufgrund ihres Versprechens von Portabilität und Geschwindigkeit haben sich vir- tuelle Maschinen (VMs) für höhere Programmiersprachen in der letzten Dekade auf breiter Front durchgesetzt. Häufig ist ihr Design jedoch nur darauf ausgelegt, eine einzige Sprache gut zu unterstützen. So wurde das Design der Java Virtual Machine (JVM) zum Beispiel stark durch das Design der Programmiersprache Java beeinflusst. Trotz ihrer aktuellen Ausrichtung auf Java hat sich insbesondere die JVM als Plattform für eine Vielzahl von neuer Programmiersprachen etabliert, darunter Sca- la, Groovy und Clojure. Dieser Entwicklung wurde in der Forschung zu JVMs bisher jedoch wenig Rechnung getragen; alle großen Benchmark Suites für die JVM sind immer noch stark auf Java als Sprache anstatt auf die Plattform als Ganzes fo- kussiert. Dieser Zustand droht, die systematische Bevorzugung von Java auf lange Zeit festzuschreiben, da die JVM-Entwickler ihre virtuellen Maschinen für die häu- figsten Anwendungsfälle optimieren. Was aber häufig für Java ist, muss keinesfalls häufig für andere populäre Sprachen sein. Eine dieser Sprachen ist Scala, welche sowohl funktionale als auch objekt-orientierte Konzepte unterstützt und seit ihrer Veröffentlichung im Jahre 2003 stetig in der Entwicklergunst gestiegen ist. Welche Charakteristika Scala-Programme mit Java-Programmen gemein haben ist allerdings eine weitgehend ungeklärte Frage. Ein Beitrag dieser Dissertation ist daher das Erstellen einer Benchmark Suite für die Programmiersprache Scala, die mit modernen, etablierten Benchmark Suites für Java konkurrieren kann. Ein weiterer Beitrag ist eine umfassende Analyse der in der Suite enthaltenen Bench- marks und ein VM-unabhängiger Vergleich mit den Benchmarks der DaCapo 9.12 Benchmark Suite, die bisher bevorzugt in der Forschung zu JVMs eingesetzt wird. Diese Analyse
Load more

Recommended publications
  • Scala: a Functional, Object-Oriented Language COEN 171 Darren Atkinson What Is Scala? — Scala Stands for Scalable Language — It Was Created in 2004 by Martin Odersky
    Scala: A Functional, Object-Oriented Language COEN 171 Darren Atkinson What is Scala? Scala stands for Scalable Language It was created in 2004 by Martin Odersky. It was designed to grow with the demands of its users. It was designed to overcome many criticisms of Java. It is compiled to Java bytecode and is interoperable with existing Java classes and libraries. It is more of a high-level language than Java, having higher- order containers and iteration constructs built-in. It encourages a functional programming style, much like ML and Scheme. It also has advanced object-oriented features, much like Java and C++. Using Scala Using Scala is much like using Python or ML, and is not as unwieldy as using Java. The Scala interpreter can be invoked directly from the command line: $ scala Welcome to Scala 2.11.8 scala> println("Hi!") The Scala interpreter can also be given a file on the command line to execute: $ scala foo.scala Scala Syntax Scala has a Java-like syntax with braces. The assignment operator is simply =. Strings are built-in and use + for concatenation. Indexing is done using ( ) rather than [ ]. The first index is index zero. Parameterized types use [ ] rather than < >. A semicolon is inferred at the end of a line. However, since it is functional, everything is an expression and there are no “statements”. Scala Types In Java, the primitive types are not objects and wrapper classes must be used. Integer for int, Boolean for bool, etc. In Scala, everything is an object including the more “primitive” types. The Scala types are Int, Boolean, String, etc.
    [Show full text]
  • Toward Harnessing High-Level Language Virtual Machines for Further Speeding up Weak Mutation Testing
    2012 IEEE Fifth International Conference on Software Testing, Verification and Validation Toward Harnessing High-level Language Virtual Machines for Further Speeding up Weak Mutation Testing Vinicius H. S. Durelli Jeff Offutt Marcio E. Delamaro Computer Systems Department Software Engineering Computer Systems Department Universidade de Sao˜ Paulo George Mason University Universidade de Sao˜ Paulo Sao˜ Carlos, SP, Brazil Fairfax, VA, USA Sao˜ Carlos, SP, Brazil [email protected] [email protected] [email protected] Abstract—High-level language virtual machines (HLL VMs) have tried to exploit the control that HLL VMs exert over run- are now widely used to implement high-level programming ning programs to facilitate and speedup software engineering languages. To a certain extent, their widespread adoption is due activities. Thus, this research suggests that software testing to the software engineering benefits provided by these managed execution environments, for example, garbage collection (GC) activities can benefit from HLL VMs support. and cross-platform portability. Although HLL VMs are widely Test tools are usually built on top of HLL VMs. However, used, most research has concentrated on high-end optimizations they often end up tampering with the emergent computation. such as dynamic compilation and advanced GC techniques. Few Using features within the HLL VMs can avoid such problems. efforts have focused on introducing features that automate or fa- Moreover, embedding testing tools within HLL VMs can cilitate certain software engineering activities, including software testing. This paper suggests that HLL VMs provide a reasonable significantly speedup computationally expensive techniques basis for building an integrated software testing environment. As such as mutation testing [6].
    [Show full text]
  • Real-Time Java for Embedded Devices: the Javamen Project*
    REAL-TIME JAVA FOR EMBEDDED DEVICES: THE JAVAMEN PROJECT* A. Borg, N. Audsley, A. Wellings The University of York, UK ABSTRACT: Hardware Java-specific processors have been shown to provide the performance benefits over their software counterparts that make Java a feasible environment for executing even the most computationally expensive systems. In most cases, the core of these processors is a simple stack machine on which stack operations and logic and arithmetic operations are carried out. More complex bytecodes are implemented either in microcode through a sequence of stack and memory operations or in Java and therefore through a set of bytecodes. This paper investigates the Figure 1: Three alternatives for executing Java code (take from (6)) state-of-the-art in Java processors and identifies two areas of improvement for specialising these processors timeliness as a key issue. The language therefore fails to for real-time applications. This is achieved through a allow more advanced temporal requirements of threads combination of the implementation of real-time Java to be expressed and virtual machine implementations components in hardware and by using application- may behave unpredictably in this context. For example, specific characteristics expressed at the Java level to whereas a basic thread priority can be specified, it is not drive a co-design strategy. An implementation of these required to be observed by a virtual machine and there propositions will provide a flexible Ravenscar- is no guarantee that the highest priority thread will compliant virtual machine that provides better preempt lower priority threads. In order to address this performance while still guaranteeing real-time shortcoming, two competing specifications have been requirements.
    [Show full text]
  • Zing:® the Best JVM for the Enterprise
    PRODUCT DATA SHEET Zing:® ZING The best JVM for the enterprise Zing Runtime for Java A JVM that is compatible and compliant The Performance Standard for Low Latency, with the Java SE specification. Zing is a Memory-Intensive or Interactive Applications better alternative to your existing JVM. INTRODUCING ZING Zing Vision (ZVision) Today Java is ubiquitous across the enterprise. Flexible and powerful, Java is the ideal choice A zero-overhead, always-on production- for development teams worldwide. time monitoring tool designed to support rapid troubleshooting of applications using Zing. Zing builds upon Java’s advantages by delivering a robust, highly scalable Java Virtual Machine ReadyNow! Technology (JVM) to match the needs of today’s real time enterprise. Zing is the best JVM choice for all Solves Java warm-up problems, gives Java workloads, including low-latency financial systems, SaaS or Cloud-based deployments, developers fine-grained control over Web-based eCommerce applications, insurance portals, multi-user gaming platforms, Big Data, compilation and allows DevOps to save and other use cases -- anywhere predictable Java performance is essential. and reuse accumulated optimizations. Zing enables developers to make effective use of memory -- without the stalls, glitches and jitter that have been part of Java’s heritage, and solves JVM “warm-up” problems that can degrade ZING ADVANTAGES performance at start up. With improved memory-handling and a more stable, consistent runtime Takes advantage of the large memory platform, Java developers can build and deploy richer applications incorporating real-time data and multiple CPU cores available in processing and analytics, driving new revenue and supporting new business innovations.
    [Show full text]
  • Bypassing Portability Pitfalls of High-Level Low-Level Programming
    Bypassing Portability Pitfalls of High-level Low-level Programming Yi Lin, Stephen M. Blackburn Australian National University [email protected], [email protected] Abstract memory-safety, encapsulation, and strong abstraction over hard- Program portability is an important software engineering consider- ware [12], which are desirable goals for system programming as ation. However, when high-level languages are extended to effec- well. Thus, high-level languages are potential candidates for sys- tively implement system projects for software engineering gain and tem programming. safety, portability is compromised—high-level code for low-level Prior research has focused on the feasibility and performance of programming cannot execute on a stock runtime, and, conversely, applying high-level languages to system programming [1, 7, 10, a runtime with special support implemented will not be portable 15, 16, 21, 22, 26–28]. The results showed that, with proper ex- across different platforms. tension and restriction, high-level languages are able to undertake We explore the portability pitfall of high-level low-level pro- the task of low-level programming, while preserving type-safety, gramming in the context of virtual machine implementation tasks. memory-safety, encapsulation and abstraction. Notwithstanding the Our approach is designing a restricted high-level language called cost for dynamic compilation and garbage collection, the perfor- RJava, with a flexible restriction model and effective low-level ex- mance of high-level languages when used to implement a virtual tensions, which is suitable for different scopes of virtual machine machine is still competitive with using a low-level language [2]. implementation, and also suitable for a low-level language bypass Using high-level languages to architect large systems is bene- for improved portability.
    [Show full text]
  • Here I Led Subcommittee Reports Related to Data-Intensive Science and Post-Moore Computing) and in CRA’S Board of Directors Since 2015
    Vivek Sarkar Curriculum Vitae Contents 1 Summary 2 2 Education 3 3 Professional Experience 3 3.1 2017-present: College of Computing, Georgia Institute of Technology . 3 3.2 2007-present: Department of Computer Science, Rice University . 5 3.3 1987-2007: International Business Machines Corporation . 7 4 Professional Awards 11 5 Research Awards 12 6 Industry Gifts 15 7 Graduate Student and Other Mentoring 17 8 Professional Service 19 8.1 Conference Committees . 20 8.2 Advisory/Award/Review/Steering Committees . 25 9 Keynote Talks, Invited Talks, Panels (Selected) 27 10 Teaching 33 11 Publications 37 11.1 Refereed Conference and Journal Publications . 37 11.2 Refereed Workshop Publications . 51 11.3 Books, Book Chapters, and Edited Volumes . 58 12 Patents 58 13 Software Artifacts (Selected) 59 14 Personal Information 60 Page 1 of 60 01/06/2020 1 Summary Over thirty years of sustained contributions to programming models, compilers and runtime systems for high performance computing, which include: 1) Leading the development of ASTI during 1991{1996, IBM's first product compiler component for optimizing locality, parallelism, and the (then) new FORTRAN 90 high-productivity array language (ASTI has continued to ship as part of IBM's XL Fortran product compilers since 1996, and was also used as the foundation for IBM's High Performance Fortran compiler product); 2) Leading the research and development of the open source Jikes Research Virtual Machine at IBM during 1998{2001, a first-of-a-kind Java Virtual Machine (JVM) and dynamic compiler implemented
    [Show full text]
  • A Hardware Abstraction Layer in Java
    A Hardware Abstraction Layer in Java MARTIN SCHOEBERL Vienna University of Technology, Austria STEPHAN KORSHOLM Aalborg University, Denmark TOMAS KALIBERA Purdue University, USA and ANDERS P. RAVN Aalborg University, Denmark Embedded systems use specialized hardware devices to interact with their environment, and since they have to be dependable, it is attractive to use a modern, type-safe programming language like Java to develop programs for them. Standard Java, as a platform independent language, delegates access to devices, direct memory access, and interrupt handling to some underlying operating system or kernel, but in the embedded systems domain resources are scarce and a Java virtual machine (JVM) without an underlying middleware is an attractive architecture. The contribution of this paper is a proposal for Java packages with hardware objects and interrupt handlers that interface to such a JVM. We provide implementations of the proposal directly in hardware, as extensions of standard interpreters, and finally with an operating system middleware. The latter solution is mainly seen as a migration path allowing Java programs to coexist with legacy system components. An important aspect of the proposal is that it is compatible with the Real-Time Specification for Java (RTSJ). Categories and Subject Descriptors: D.4.7 [Operating Systems]: Organization and Design—Real-time sys- tems and embedded systems; D.3.3 [Programming Languages]: Language Classifications—Object-oriented languages; D.3.3 [Programming Languages]: Language Constructs and Features—Input/output General Terms: Languages, Design, Implementation Additional Key Words and Phrases: Device driver, embedded system, Java, Java virtual machine 1. INTRODUCTION When developing software for an embedded system, for instance an instrument, it is nec- essary to control specialized hardware devices, for instance a heating element or an inter- ferometer mirror.
    [Show full text]
  • Techniques for Real-System Characterization of Java Virtual Machine Energy and Power Behavior Gilberto Contreras Margaret Martonosi
    Techniques for Real-System Characterization of Java Virtual Machine Energy and Power Behavior Gilberto Contreras Margaret Martonosi Department of Electrical Engineering Princeton University 1 Why Study Power in Java Systems? The Java platform has been adopted in a wide variety of devices Java servers demand performance, embedded devices require low-power Performance is important, power/energy/thermal issues are equally important How do we study and characterize these requirements in a multi-layer platform? 2 Power/Performance Design Issues Java Application Java Virtual Machine Operating System Hardware 3 Power/Performance Design Issues Java Application Garbage Class Runtime Execution Collection LoaderJava VirtualCompiler MachineEngine Operating System Hardware How do the various software layers affect power/performance characteristics of hardware? Where should time be invested when designing power and/or thermally aware Java virtual Machines? 4 Outline Approaches for Energy/Performance Characterization of Java virtual machines Methodology Breaking the JVM into sub-components Hardware-based power/performance characterization of JVM sub-components Results Jikes & Kaffe on Pentium M Kaffe on Intel XScale Conclusions 5 Power & Performance Analysis of Java Simulation Approach √ Flexible: easy to model non-existent hardware x Simulators may lack comprehensiveness and accuracy x Thermal studies require tens of seconds granularity Accurate simulators are too slow Hardware Approach √ Able to capture full-system characteristics
    [Show full text]
  • Apache Harmony Project Tim Ellison Geir Magnusson Jr
    The Apache Harmony Project Tim Ellison Geir Magnusson Jr. Apache Harmony Project http://harmony.apache.org TS-7820 2007 JavaOneSM Conference | Session TS-7820 | Goal of This Talk In the next 45 minutes you will... Learn about the motivations, current status, and future plans of the Apache Harmony project 2007 JavaOneSM Conference | Session TS-7820 | 2 Agenda Project History Development Model Modularity VM Interface How Are We Doing? Relevance in the Age of OpenJDK Summary 2007 JavaOneSM Conference | Session TS-7820 | 3 Agenda Project History Development Model Modularity VM Interface How Are We Doing? Relevance in the Age of OpenJDK Summary 2007 JavaOneSM Conference | Session TS-7820 | 4 Apache Harmony In the Beginning May 2005—founded in the Apache Incubator Primary Goals 1. Compatible, independent implementation of Java™ Platform, Standard Edition (Java SE platform) under the Apache License 2. Community-developed, modular architecture allowing sharing and independent innovation 3. Protect IP rights of ecosystem 2007 JavaOneSM Conference | Session TS-7820 | 5 Apache Harmony Early history: 2005 Broad community discussion • Technical issues • Legal and IP issues • Project governance issues Goal: Consolidation and Consensus 2007 JavaOneSM Conference | Session TS-7820 | 6 Early History Early history: 2005/2006 Initial Code Contributions • Three Virtual machines ● JCHEVM, BootVM, DRLVM • Class Libraries ● Core classes, VM interface, test cases ● Security, beans, regex, Swing, AWT ● RMI and math 2007 JavaOneSM Conference | Session TS-7820 |
    [Show full text]
  • A Post-Apocalyptic Sun.Misc.Unsafe World
    A Post-Apocalyptic sun.misc.Unsafe World http://www.superbwallpapers.com/fantasy/post-apocalyptic-tower-bridge-london-26546/ Chris Engelbert Twitter: @noctarius2k Jatumba! 2014, 2015, 2016, … Disclaimer This talk is not going to be negative! Disclaimer But certain things are highly speculative and APIs or ideas might change by tomorrow! sun.misc.Scissors http://www.underwhelmedcomic.com/wp-content/uploads/2012/03/runningdude.jpg sun.misc.Unsafe - What you (don’t) know sun.misc.Unsafe - What you (don’t) know • Internal class (sun.misc Package) sun.misc.Unsafe - What you (don’t) know • Internal class (sun.misc Package) sun.misc.Unsafe - What you (don’t) know • Internal class (sun.misc Package) • Used inside the JVM / JRE sun.misc.Unsafe - What you (don’t) know • Internal class (sun.misc Package) • Used inside the JVM / JRE // Unsafe mechanics private static final sun.misc.Unsafe U; private static final long QBASE; private static final long QLOCK; private static final int ABASE; private static final int ASHIFT; static { try { U = sun.misc.Unsafe.getUnsafe(); Class<?> k = WorkQueue.class; Class<?> ak = ForkJoinTask[].class; example: QBASE = U.objectFieldOffset (k.getDeclaredField("base")); java.util.concurrent.ForkJoinPool QLOCK = U.objectFieldOffset (k.getDeclaredField("qlock")); ABASE = U.arrayBaseOffset(ak); int scale = U.arrayIndexScale(ak); if ((scale & (scale - 1)) != 0) throw new Error("data type scale not a power of two"); ASHIFT = 31 - Integer.numberOfLeadingZeros(scale); } catch (Exception e) { throw new Error(e); } } } sun.misc.Unsafe
    [Show full text]
  • Fedora Core, Java™ and You
    Fedora Core, Java™ and You Gary Benson Software Engineer What is Java? The word ªJavaº is used to describe three things: The Java programming language The Java virtual machine The Java platform To support Java applications Fedora needs all three. What Fedora uses: GCJ and ECJ GCJ is the core of Fedora©s Java support: GCJ includes gcj, a compiler for the Java programming language. GCJ also has a runtime and class library, collectively called libgcj. The class library is separately known as GNU Classpath. ECJ is the Eclipse Compiler for Java: GCJ©s compiler gcj is not used for ªtraditionalº Java compilation. More on that later... Why libgcj? There are many free Java Virtual machines: Cacao, IKVM, JamVM, Jikes RVM, Kaffe, libgcj, Sable VM, ... There are two main reasons Fedora uses libgcj: Availability on many platforms. Ability to use precompiled native code. GNU Classpath Free core class library for Java virtual machines and compilers. The JPackage Project A collection of some 1,600 Java software packages for Linux: Distribution-agnostic RPM packages. Both runtimes/development kits and applications. Segregation between free and non-free packages. All free packages built entirely from source. Multiple runtimes/development kits may be installed. Fedora includes: JPackage-compatible runtime and development kit packages. A whole bunch of applications. JPackage JOnAS Fedora©s Java Compilers gcj can operate in several modes: Java source (.java) to Java bytecode (.class) Java source (.java) to native machine code (.o) Java bytecode (.class, .jar) to native machine code (.o) In Fedora: ECJ compiles Java source to bytecode. gcj compiles that bytecode to native machine code.
    [Show full text]
  • Nashorn Architecture and Performance Improvements in the Upcoming JDK 8U40 Release
    Oracle Blogs Home Products & Services Downloads Support Partners Communities About Login Oracle Blog Nashorn JavaScript for the JVM. Nashorn architecture and performance improvements in the upcoming JDK 8u40 release By lagergren on Dec 12, 2014 Hello everyone! We've been bad att blogging here for a while. Apologizes for that. I thought it would be prudent to talk a little bit about OpenJDK 8u40 which is now code frozen, and what enhancements we have made for Nashorn. 8u40 includes a total rewrite of the Nashorn code generator, which now contains the optimistic type system. JavaScript, or any dynamic language for that matter, doesn't have enough statically available type information to provide performant code, just by doing compile time analysis. That's why we have designed the new type system to get around this performance bottleneck. While Java bytecode, which is the output of the Nashorn JIT, is strongly typed and JavaScript isn't, there are problems translating the AST to optimal bytecode. Attila Szegedi, Hannes Wallnöfer and myself have spent significant time researching and implementing this the last year. Background: Conservatively, when implementing a JavaScript runtime in Java, anything known to be a number can be represented in Java as a double, and everything else can be represented as an Object. This includes numbers, ints, longs and other primitive types that aren't statically provable. Needless to say, this approach leads to a lot of internal boxing, which is quite a bottleneck for dynamic language execution speed on the JVM. The JVM is very good at optimizing Java-like bytecode, and this is not Java-like bytecode.
    [Show full text]