Discussing open sourcing the IBM J9 JVM GC technology as part of a language agnostic toolkit. It has demos showing how easy it is to use the GC in another language as well as results on our MRI example
GraalVM can be used as a drop-in replacement for the JDK to run Java programs. It includes the Graal just-in-time compiler which can provide better performance than the default HotSpot compiler. GraalVM also allows ahead-of-time compilation of Java bytecode into native images using SubstrateVM, eliminating the overhead of interpretation and compilation at runtime. These native images have minimal dependencies and fast startup times, making them suitable for containerized microservices and cloud applications.
Eclipse OMR: a modern toolkit for building language runtimesMark Stoodley
Eclipse OMR is a modern toolkit for building language runtimes that provides high quality runtime ingredients like a porting library, threading library, garbage collection framework, and JIT compiler tools. It has no language semantics of its own and is designed to be integrated into various language runtimes. The presentation demonstrates how OMR has already been used successfully in Ruby, Python, and Smalltalk runtimes and provides performance benefits. It invites others to get involved in the open source project.
GraalVM can be used as a drop-in replacement for the JDK to run Java programs. It includes the Graal just-in-time compiler which can provide better performance than the default HotSpot compiler. GraalVM also includes the native-image tool which can compile Java bytecode ahead-of-time to native executables without dependencies, improving startup time significantly. This enables using Java for more dynamic workloads like microservices that require fast startup. Reflection and dynamic proxies require additional configuration for native images. Docker images can also be built from native executables to distribute applications.
GraalVM is a new polyglot virtual machine that allows running JVM languages as well as other languages like JavaScript, Python, and R. It provides several advantages over traditional JVMs including being a drop-in replacement for OpenJDK that can improve performance, the ability to ahead-of-time compile Java programs into native images for faster startup times, seamless interoperability between supported languages, and common debugging and monitoring interfaces. Key features include running as a replacement JVM, including Graal as an alternative JIT compiler in OpenJDK 11, ahead-of-time compilation to native images, support for additional languages via Truffle, and allowing Java programs to be used as native libraries from other languages.
HOW AND WHY GRAALVM IS QUICKLY BECOMING RELEVANT FOR YOULucas Jellema
This document provides an overview of GraalVM, including what it is, its key features, and how it can be used. GraalVM is a polyglot virtual machine that allows running applications written in multiple languages. It includes a just-in-time (JIT) compiler that can speed up Java applications, an ahead-of-time (AOT) compiler to create native binaries, and language interoperability features. The document demonstrates how GraalVM allows Java applications to leverage code and modules written in other languages like JavaScript, and how it enables building polyglot applications that combine languages. It also discusses using GraalVM's AOT compiler to package polyglot applications into standalone executables.
This document discusses the LLVM compiler system and its approach. LLVM aims to build modular compiler components that implement modern techniques, integrate well together, have few dependencies, and integrate with existing tools. This allows compilers built with LLVM components to share code and improvements, choose the best components, and be constructed quickly. The document provides llvm-gcc as an example client that uses GCC's front-end but replaces the optimizer and code generator with LLVM's modern ones to gain benefits like interprocedural optimizations, aggressive loop optimizations, and retargetable code generation.
This document provides an overview of Mono, an open source implementation of Microsoft's .NET Framework that allows developers to build and run .NET applications on Linux, macOS, Windows, and other operating systems. It discusses Mono's architecture, language support, ongoing development efforts, and roadmap, including plans to support additional .NET features like Windows Forms, ASP.NET, C# 3.0, and technologies from .NET 3.0 like Windows Communication Foundation and Windows Workflow Foundation.
GraalVM can be used as a drop-in replacement for the JDK to run Java programs. It includes the Graal just-in-time compiler which can provide better performance than the default HotSpot compiler. GraalVM also allows ahead-of-time compilation of Java bytecode into native images using SubstrateVM, eliminating the overhead of interpretation and compilation at runtime. These native images have minimal dependencies and fast startup times, making them suitable for containerized microservices and cloud applications.
Eclipse OMR: a modern toolkit for building language runtimesMark Stoodley
Eclipse OMR is a modern toolkit for building language runtimes that provides high quality runtime ingredients like a porting library, threading library, garbage collection framework, and JIT compiler tools. It has no language semantics of its own and is designed to be integrated into various language runtimes. The presentation demonstrates how OMR has already been used successfully in Ruby, Python, and Smalltalk runtimes and provides performance benefits. It invites others to get involved in the open source project.
GraalVM can be used as a drop-in replacement for the JDK to run Java programs. It includes the Graal just-in-time compiler which can provide better performance than the default HotSpot compiler. GraalVM also includes the native-image tool which can compile Java bytecode ahead-of-time to native executables without dependencies, improving startup time significantly. This enables using Java for more dynamic workloads like microservices that require fast startup. Reflection and dynamic proxies require additional configuration for native images. Docker images can also be built from native executables to distribute applications.
GraalVM is a new polyglot virtual machine that allows running JVM languages as well as other languages like JavaScript, Python, and R. It provides several advantages over traditional JVMs including being a drop-in replacement for OpenJDK that can improve performance, the ability to ahead-of-time compile Java programs into native images for faster startup times, seamless interoperability between supported languages, and common debugging and monitoring interfaces. Key features include running as a replacement JVM, including Graal as an alternative JIT compiler in OpenJDK 11, ahead-of-time compilation to native images, support for additional languages via Truffle, and allowing Java programs to be used as native libraries from other languages.
HOW AND WHY GRAALVM IS QUICKLY BECOMING RELEVANT FOR YOULucas Jellema
This document provides an overview of GraalVM, including what it is, its key features, and how it can be used. GraalVM is a polyglot virtual machine that allows running applications written in multiple languages. It includes a just-in-time (JIT) compiler that can speed up Java applications, an ahead-of-time (AOT) compiler to create native binaries, and language interoperability features. The document demonstrates how GraalVM allows Java applications to leverage code and modules written in other languages like JavaScript, and how it enables building polyglot applications that combine languages. It also discusses using GraalVM's AOT compiler to package polyglot applications into standalone executables.
This document discusses the LLVM compiler system and its approach. LLVM aims to build modular compiler components that implement modern techniques, integrate well together, have few dependencies, and integrate with existing tools. This allows compilers built with LLVM components to share code and improvements, choose the best components, and be constructed quickly. The document provides llvm-gcc as an example client that uses GCC's front-end but replaces the optimizer and code generator with LLVM's modern ones to gain benefits like interprocedural optimizations, aggressive loop optimizations, and retargetable code generation.
This document provides an overview of Mono, an open source implementation of Microsoft's .NET Framework that allows developers to build and run .NET applications on Linux, macOS, Windows, and other operating systems. It discusses Mono's architecture, language support, ongoing development efforts, and roadmap, including plans to support additional .NET features like Windows Forms, ASP.NET, C# 3.0, and technologies from .NET 3.0 like Windows Communication Foundation and Windows Workflow Foundation.
Experiments were conducted utilizing OMR technologies in Ruby MRI. OMR is an open source toolkit that implements language-agnostic parts of a managed runtime. It allows incremental development of new runtimes and consumption of advanced functionality. A preview of Ruby integrated with OMR included garbage collection, just-in-time compilation, and diagnostic tooling improvements. Further work was suggested to improve performance and remove limitations of the Ruby interpreter.
The document discusses the use of open source software in amateur robotics, focusing on the speaker's robot Magellan project. It describes the dual-computer architecture using a PIC microcontroller and NSLU2 computer running Linux. It also discusses the open source tools used, including the JAL compiler for the PIC, OpenEmbedded for building the Linux system, and Python for high-level control code.
Highly Surmountable Challenges in Ruby+OMR JIT CompilationMatthew Gaudet
The Ruby+OMR JIT compiler adds a JIT to CRuby. However, it has challenges to surmount before it will provide broad improvement to Ruby applications that aren’t micro-benchmarks. This talk will cover some of those challenges, along with some brainstorming about potential ways to tackle them.
The Ruby+OMR JIT compiler is one way to add JIT compilation to the CRuby interpreter. However, it has a number of challenges to surmount before it will provide broad improvement to Ruby applications that aren’t micro-benchmarks. This talk will cover some of those challenges, along with some brainstorming about potential ways to tackle them.
The document discusses implementing dynamic programming languages in virtual machines. It argues against directly writing virtual machines in low-level languages like C, which can limit flexibility, maintainability and performance. Instead, it advocates writing interpreters in high-level languages and using meta-programming techniques to automatically generate virtual machines from these interpreters through translation. This approach aims to achieve flexibility, simplicity and performance together for language implementations.
Launchpad is a Python-based web application with over 350k lines of code and 25k tests. It was developed primarily by Canonical using Zope 3, Twisted, and other libraries. The presentation discusses best practices from Launchpad's development including extensive testing, code reviews, use of branches, and interfaces. It also covers challenges like slow tests and database evolution.
PyPy is a Python implementation that uses a just-in-time (JIT) compiler. It is written in RPython, a restricted subset of Python, and uses a translation framework to generate C code from RPython programs. This allows PyPy to run programs faster than the standard CPython implementation while also supporting features like lazy evaluation, pluggable object spaces, and stackless concurrency.
The core idea of PyPy is to produce a flexible and fast implementation of the Python programming language. The talk will cover the interpreter, translator and jit parts of the code and their relationships and the fundamental ways in which PyPy differs from other virtual machine implementations.
J9: Under the hood of the next open source JVMDanHeidinga
A description of how bytecodes are loaded into the J9VM and how bytecode execution occurs, plus IBM's plans to open source J9.
Session is the "new hire" talk given to all new J9 VM team members.
LLVM is a compiler and toolkit for building compilers that converts source code into machine-readable code. It started at the University of Illinois in 2000 and provides modular, reusable technologies. LLVM differs from GCC in that it is a framework for generating code from any source, rather than supporting specific languages. It works by using Clang to turn source into an intermediate representation, then optimizes and converts it to machine code. LLVM can optimize code aggressively during compilation and linking but does not handle language parsing or memory management itself.
The document discusses the LLVM compiler framework and infrastructure. It provides reusable components for building compilers to reduce the time and cost of building new compilers. The LLVM compiler framework uses the LLVM infrastructure to build static compilers, JITs, and trace-based optimizers. It emits C code or native code for x86, Sparc, and PowerPC architectures. The three primary LLVM components are the virtual instruction set (the common language- and target-independent intermediate representation), a collection of well-integrated libraries, and a collection of tools built from the libraries.
Project Zero PHP talk at JavaOne 2008.
This talk describes IBM WebSphere sMash and the PHP support within it. For more information visit http://www.projectzero.org
Updates on the current status of Graal VM, a platform dedicated to run multiple programming languages at excellent performance. Experimental binaries are available from http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html.
CommunityOneEast 09 - Dynamic Languages: the next big thing for the JVM or an...Chris Richardson
Dynamic languages have many benefits but static languages with compile-time checking can also be expressive. The document discusses the rise of dynamic languages on the Java Virtual Machine like Groovy and how they provide benefits like concise syntax and runtime programmability while static languages provide safety through compile-time checking. It then outlines Chris Richardson's presentation agenda on dynamic languages, favorite Groovy features, frustrations with Groovy, and the Scala language which aims to provide both expressiveness and compile-time checking.
Debugging of CPython processes with gdb
Slides for the PyconPL 2016 talk on how to use gdb for debugging of complex issues that might happen with CPython
Blog post version: http://podoliaka.org/2016/04/10/debugging-cpython-gdb/
Graal is a dynamic meta-circular research compiler for Java that is designed for extensibility and modularity. One of its main distinguishing elements is the handling of optimistic assumptions obtained via profiling feedback and the representation of deoptimization guards in the compiled code. Truffle is a self-optimizing runtime system on top of Graal that uses partial evaluation to derive compiled code from interpreters. Truffle is suitable for creating high-performance implementations for dynamic languages with only moderate effort. The presentation includes a description of the Truffle multi-language API and performance comparisons within the industry of current prototype Truffle language implementations (JavaScript, Ruby, and R). Both Graal and Truffle are open source and form themselves research platforms in the area of virtual machine and programming language implementation (http://openjdk.java.net/projects/graal/).
BP207 - Meet the Java Application Server You Already Own – IBM DominoSerdar Basegmez
This document discusses preparing the runtime and development environments for DOTS (Domino OSGi Tasklet Service) on IBM Domino. It describes copying necessary JAR files and executable files to directories within the Domino program folder to prepare the runtime environment. It also mentions that the Eclipse IDE is needed for developing DOTS tasklets as OSGi bundles, and steps will be provided for configuring Eclipse to develop plugins that can run on the Domino OSGi environment.
FOSDEM 2017 - Open J9 The Next Free Java VMCharlie Gracie
I will discuss the J9 VM technology and our plans on open sourcing the technology. My team has already open sourced a lot of the underlying technology as part of the Eclipse OMR project and now we are working open sourcing the rest of the technology.
This document contains the agenda and slides from a presentation given at the TURBO'18 workshop on November 5, 2018. The presentation was titled "Eclipse OMR: Building Blocks for Polyglot" and was given by Xiaoli (Shelley) Liang. The presentation discussed Eclipse OMR, an open-source C++ library for building language runtimes. It described OMR's motivation of enabling reuse across languages to reduce costs, its core components, example projects using OMR, outreach efforts, and ways to get involved with the project.
Experiments were conducted utilizing OMR technologies in Ruby MRI. OMR is an open source toolkit that implements language-agnostic parts of a managed runtime. It allows incremental development of new runtimes and consumption of advanced functionality. A preview of Ruby integrated with OMR included garbage collection, just-in-time compilation, and diagnostic tooling improvements. Further work was suggested to improve performance and remove limitations of the Ruby interpreter.
The document discusses the use of open source software in amateur robotics, focusing on the speaker's robot Magellan project. It describes the dual-computer architecture using a PIC microcontroller and NSLU2 computer running Linux. It also discusses the open source tools used, including the JAL compiler for the PIC, OpenEmbedded for building the Linux system, and Python for high-level control code.
Highly Surmountable Challenges in Ruby+OMR JIT CompilationMatthew Gaudet
The Ruby+OMR JIT compiler adds a JIT to CRuby. However, it has challenges to surmount before it will provide broad improvement to Ruby applications that aren’t micro-benchmarks. This talk will cover some of those challenges, along with some brainstorming about potential ways to tackle them.
The Ruby+OMR JIT compiler is one way to add JIT compilation to the CRuby interpreter. However, it has a number of challenges to surmount before it will provide broad improvement to Ruby applications that aren’t micro-benchmarks. This talk will cover some of those challenges, along with some brainstorming about potential ways to tackle them.
The document discusses implementing dynamic programming languages in virtual machines. It argues against directly writing virtual machines in low-level languages like C, which can limit flexibility, maintainability and performance. Instead, it advocates writing interpreters in high-level languages and using meta-programming techniques to automatically generate virtual machines from these interpreters through translation. This approach aims to achieve flexibility, simplicity and performance together for language implementations.
Launchpad is a Python-based web application with over 350k lines of code and 25k tests. It was developed primarily by Canonical using Zope 3, Twisted, and other libraries. The presentation discusses best practices from Launchpad's development including extensive testing, code reviews, use of branches, and interfaces. It also covers challenges like slow tests and database evolution.
PyPy is a Python implementation that uses a just-in-time (JIT) compiler. It is written in RPython, a restricted subset of Python, and uses a translation framework to generate C code from RPython programs. This allows PyPy to run programs faster than the standard CPython implementation while also supporting features like lazy evaluation, pluggable object spaces, and stackless concurrency.
The core idea of PyPy is to produce a flexible and fast implementation of the Python programming language. The talk will cover the interpreter, translator and jit parts of the code and their relationships and the fundamental ways in which PyPy differs from other virtual machine implementations.
J9: Under the hood of the next open source JVMDanHeidinga
A description of how bytecodes are loaded into the J9VM and how bytecode execution occurs, plus IBM's plans to open source J9.
Session is the "new hire" talk given to all new J9 VM team members.
LLVM is a compiler and toolkit for building compilers that converts source code into machine-readable code. It started at the University of Illinois in 2000 and provides modular, reusable technologies. LLVM differs from GCC in that it is a framework for generating code from any source, rather than supporting specific languages. It works by using Clang to turn source into an intermediate representation, then optimizes and converts it to machine code. LLVM can optimize code aggressively during compilation and linking but does not handle language parsing or memory management itself.
The document discusses the LLVM compiler framework and infrastructure. It provides reusable components for building compilers to reduce the time and cost of building new compilers. The LLVM compiler framework uses the LLVM infrastructure to build static compilers, JITs, and trace-based optimizers. It emits C code or native code for x86, Sparc, and PowerPC architectures. The three primary LLVM components are the virtual instruction set (the common language- and target-independent intermediate representation), a collection of well-integrated libraries, and a collection of tools built from the libraries.
Project Zero PHP talk at JavaOne 2008.
This talk describes IBM WebSphere sMash and the PHP support within it. For more information visit http://www.projectzero.org
Updates on the current status of Graal VM, a platform dedicated to run multiple programming languages at excellent performance. Experimental binaries are available from http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html.
CommunityOneEast 09 - Dynamic Languages: the next big thing for the JVM or an...Chris Richardson
Dynamic languages have many benefits but static languages with compile-time checking can also be expressive. The document discusses the rise of dynamic languages on the Java Virtual Machine like Groovy and how they provide benefits like concise syntax and runtime programmability while static languages provide safety through compile-time checking. It then outlines Chris Richardson's presentation agenda on dynamic languages, favorite Groovy features, frustrations with Groovy, and the Scala language which aims to provide both expressiveness and compile-time checking.
Debugging of CPython processes with gdb
Slides for the PyconPL 2016 talk on how to use gdb for debugging of complex issues that might happen with CPython
Blog post version: http://podoliaka.org/2016/04/10/debugging-cpython-gdb/
Graal is a dynamic meta-circular research compiler for Java that is designed for extensibility and modularity. One of its main distinguishing elements is the handling of optimistic assumptions obtained via profiling feedback and the representation of deoptimization guards in the compiled code. Truffle is a self-optimizing runtime system on top of Graal that uses partial evaluation to derive compiled code from interpreters. Truffle is suitable for creating high-performance implementations for dynamic languages with only moderate effort. The presentation includes a description of the Truffle multi-language API and performance comparisons within the industry of current prototype Truffle language implementations (JavaScript, Ruby, and R). Both Graal and Truffle are open source and form themselves research platforms in the area of virtual machine and programming language implementation (http://openjdk.java.net/projects/graal/).
BP207 - Meet the Java Application Server You Already Own – IBM DominoSerdar Basegmez
This document discusses preparing the runtime and development environments for DOTS (Domino OSGi Tasklet Service) on IBM Domino. It describes copying necessary JAR files and executable files to directories within the Domino program folder to prepare the runtime environment. It also mentions that the Eclipse IDE is needed for developing DOTS tasklets as OSGi bundles, and steps will be provided for configuring Eclipse to develop plugins that can run on the Domino OSGi environment.
FOSDEM 2017 - Open J9 The Next Free Java VMCharlie Gracie
I will discuss the J9 VM technology and our plans on open sourcing the technology. My team has already open sourced a lot of the underlying technology as part of the Eclipse OMR project and now we are working open sourcing the rest of the technology.
This document contains the agenda and slides from a presentation given at the TURBO'18 workshop on November 5, 2018. The presentation was titled "Eclipse OMR: Building Blocks for Polyglot" and was given by Xiaoli (Shelley) Liang. The presentation discussed Eclipse OMR, an open-source C++ library for building language runtimes. It described OMR's motivation of enabling reuse across languages to reduce costs, its core components, example projects using OMR, outreach efforts, and ways to get involved with the project.
This document discusses GraalVM, a universal virtual machine that enables high performance and interoperability between programming languages. It introduces key concepts like JIT compilation, AOT compilation, C2 JIT, Graal JIT, and Substrate VM. It provides examples of using Graal JIT and AOT compilers on a sample Java application and compares the performance. Finally, it summarizes the capabilities and future directions of GraalVM, including running existing applications more efficiently across languages and embedding languages in native applications.
(java2days) Is the Future of Java Cloudy?Steve Poole
This document discusses how Java can remain relevant in the future by evolving to meet new demands and competing technologies. It provides the results of several microbenchmarks comparing Java to other languages like Node, Swift, Go, Python and Ruby. The benchmarks show Java performing competitively in most cases. The document argues that Java's strengths like being type safe, garbage collected, and able to run on all platforms position it well for cloud, data analytics and machine learning workloads. It outlines IBM's plans to invest in Java and related open source projects to accelerate innovation and ensure Java remains the platform of choice.
Simple tweaks to get the most out of your JVMJamie Coleman
Many developers don’t think about the JVM level when creating applications. It is something that just simply works. Now more applications are becoming cloud-native and we have JVM’s running in every microservice container, each performance gain can have massive benefits when scaled up. Some tweaks are very easy to implement and can have huge impacts on start-up time and performance of your applications. This talk will go through all the different JVM options and give you some easy and simple advice on how to get the most out of your JVM to save not only money but also energy on the cloud.
Introduction to Java Programming, Basic Structure, variables Data type, input...Mr. Akaash
This is First Lecture of java Programming which cover all basic points (ie. History and feature of java, Introduction to java, about variables data type and compilation....
Simple tweaks to get the most out of your jvmJamie Coleman
Many developers don’t think about the JVM level when creating applications. It is something that just simply works. Now more applications are becoming cloud-native and we have JVM’s running in every microservice container, each performance gain can have massive benefits when scaled up. Some tweaks are very easy to implement and can have huge impacts on start-up time and performance of your applications. This talk will go through all the different JVM options and give you some easy and simple advice on how to get the most out of your JVM to save not only money but also energy on the cloud.
Understand the Trade-offs Using Compilers for Java ApplicationsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2QCmmJ0.
Mark Stoodley examines some of the strengths and weaknesses of the different Java compilation technologies, if one was to apply them in isolation. Stoodley discusses how production JVMs are assembling a combination of these tools that work together to provide excellent performance across the large spectrum of applications written in Java and JVM based languages. Filmed at qconsf.com.
Mark Stoodley joined IBM Canada to build Java JIT compilers for production use and led the team that delivered AOT compilation in the IBM SDK for Java 6. He spent the last five years leading the effort to open source nearly 4.3 million lines of source code from the IBM J9 Java Virtual Machine to create the two open source projects Eclipse OMR and Eclipse OpenJ9, and now co-leads both projects.
The document discusses the Java Virtual Machine (JVM) and ways to monitor and analyze JVM performance using Splunk. It provides an overview of the history and evolution of the JVM. It then details various sources of machine data from the JVM, such as application logs, JMX, garbage collection logs, and HPROF profiling dumps, that can be ingested into Splunk. It describes how to correlate this JVM data with operating system metrics and custom instrumentation to gain insights into application performance and issues. Finally, it presents a vision of fully instrumenting the JVM and applications with Splunk for comprehensive monitoring and troubleshooting.
Introduction to Java : Feature to Java, Java Virtual Machine, Differences between C++ and Java,
Part of Java, API Document, Starting a Java Program. Important Classes, Formatting the Output
A Java Implementer's Guide to Boosting Apache Spark Performance by Tim Ellison.J On The Beach
Apache Spark has rocked the big data landscape, quickly becoming the largest open source big data community with over 750 contributors from more than 200 organizations. Spark's core tenants of speed, ease of use, and its unified programming model fit neatly with the high performance, scalable, and manageable characteristics of modern Java runtimes. In this talk we introduce the Spark programming model, and describe some unique Java runtime capabilities in the JIT, fast networking, serialization techniques, and GPU off-loading that deliver the ultimate big data platform for solving business problems. We will show how solutions, previously infeasible with regular Java programming, become possible with a high performance Spark core runtime, enabling you to solve problems smarter and faster.
The document discusses the need for a platform-independent language for developing applications that can run on heterogeneous systems. It describes how James Gosling and his team at Sun Microsystems created the Java programming language to address this need. The key aspects that allow Java to achieve platform independence are: 1) Java source code is compiled to bytecode that runs on the Java Virtual Machine (JVM) instead of native machine code, 2) The JVM specification ensures bytecode can be run on any system with a compatible JVM implementation.
JDD2015: Towards the Fastest (J)VM on the Planet! - Jaroslav TulachPROIDEA
The document discusses Oracle Labs' vision for developing the fastest virtual machine (VM) on the planet. It presents Graal VM and Truffle, frameworks that allow multiple languages to run on a single VM. Graal VM is a modern alternative to HotSpot that aims to be more maintainable and toolable. Truffle enables easy development of new languages that can run on Graal with high performance using just-in-time compilation. The document demonstrates multi-language execution and debugging using these technologies.
Gr8conf EU 2013 Speed up your development: GroovyServ and Grails Improx PluginYasuharu Nakano
The document discusses how to speed up development of Groovy and Grails applications using GroovyServ and the Improx plugin. GroovyServ launches Groovy faster by pre-invoking it as a server. The Improx plugin allows running Grails tests and commands from an IDE by connecting to an interactive Grails shell via TCP/IP. This avoids restarting the JVM for each test and provides autocompletion. Demostrations show how these tools improve development workflow by making Groovy and test execution much faster.
Multiplatform shared codebase with Kotlin/Native - UA Mobile 2019UA Mobile
If you want to share the code between Android and iOS but you don't feel like doing C++/JNI, React Native, Flutter, you must try Kotlin/Native! In this presentation we will see how Kotlin/Native is different and in some aspects superior, and how easy it becomes to develop, debug and maintain a common codebase with JetBrains tools and without sacrificing runtime performance.
Multiplatform shared codebase with Kotlin/Native - UA Mobile 2019Eugene Kurko
f you want to share the code between Android and iOS but you don't feel like doing C++/JNI, React Native, Flutter, you must try Kotlin/Native! In this presentation we will see how Kotlin/Native is different and in some aspects superior, and how easy it becomes to develop, debug and maintain a common codebase with JetBrains tools and without sacrificing runtime performance.
Java was developed in 1991 by Sun Microsystems as part of the Green project. A team member named James Gosling grew dissatisfied with C++ and created a new language called Oak, which was later renamed to Java in 1995 by Sun Microsystems. Java is an object-oriented language that is platform independent, robust, reliable, secure, and has features like compilation to bytecode, dynamic binding, and multithreading.
Introduction to the Eclipse scripting tool Groovy Monkey. Groovy Monkey allows for you to engage in API exploration, Task Automation, Plugin prototyping and collaboration in a lightweight and simple way.
Universal Java allows developers to write code once and run it anywhere, including on servers, desktops, mobiles, and IoT devices. Java code is portable because it compiles to bytecode that runs on the Java Virtual Machine (JVM), which exists for most platforms. Some key aspects that enable portability include:
1. Separating platform-independent business logic from platform-specific UI code
2. Using common language features and libraries for cross-platform code
3. Transpiling Java to other languages like JavaScript for web apps
4. Ahead-of-time compilation to native code for better performance on devices
The document discusses strategies for writing portable Java code and provides examples using shared business
E-commerce Application Development Company.pdfHornet Dynamics
Your business can reach new heights with our assistance as we design solutions that are specifically appropriate for your goals and vision. Our eCommerce application solutions can digitally coordinate all retail operations processes to meet the demands of the marketplace while maintaining business continuity.
Do you want Software for your Business? Visit Deuglo
Deuglo has top Software Developers in India. They are experts in software development and help design and create custom Software solutions.
Deuglo follows seven steps methods for delivering their services to their customers. They called it the Software development life cycle process (SDLC).
Requirement — Collecting the Requirements is the first Phase in the SSLC process.
Feasibility Study — after completing the requirement process they move to the design phase.
Design — in this phase, they start designing the software.
Coding — when designing is completed, the developers start coding for the software.
Testing — in this phase when the coding of the software is done the testing team will start testing.
Installation — after completion of testing, the application opens to the live server and launches!
Maintenance — after completing the software development, customers start using the software.
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
Most important New features of Oracle 23c for DBAs and Developers. You can get more idea from my youtube channel video from https://youtu.be/XvL5WtaC20A
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Introducing Crescat - Event Management Software for Venues, Festivals and Eve...Crescat
Crescat is industry-trusted event management software, built by event professionals for event professionals. Founded in 2017, we have three key products tailored for the live event industry.
Crescat Event for concert promoters and event agencies. Crescat Venue for music venues, conference centers, wedding venues, concert halls and more. And Crescat Festival for festivals, conferences and complex events.
With a wide range of popular features such as event scheduling, shift management, volunteer and crew coordination, artist booking and much more, Crescat is designed for customisation and ease-of-use.
Over 125,000 events have been planned in Crescat and with hundreds of customers of all shapes and sizes, from boutique event agencies through to international concert promoters, Crescat is rigged for success. What's more, we highly value feedback from our users and we are constantly improving our software with updates, new features and improvements.
If you plan events, run a venue or produce festivals and you're looking for ways to make your life easier, then we have a solution for you. Try our software for free or schedule a no-obligation demo with one of our product specialists today at crescat.io
Takashi Kobayashi and Hironori Washizaki, "SWEBOK Guide and Future of SE Education," First International Symposium on the Future of Software Engineering (FUSE), June 3-6, 2024, Okinawa, Japan
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Zoom is a comprehensive platform designed to connect individuals and teams efficiently. With its user-friendly interface and powerful features, Zoom has become a go-to solution for virtual communication and collaboration. It offers a range of tools, including virtual meetings, team chat, VoIP phone systems, online whiteboards, and AI companions, to streamline workflows and enhance productivity.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
What is Master Data Management by PiLog Groupaymanquadri279
PiLog Group's Master Data Record Manager (MDRM) is a sophisticated enterprise solution designed to ensure data accuracy, consistency, and governance across various business functions. MDRM integrates advanced data management technologies to cleanse, classify, and standardize master data, thereby enhancing data quality and operational efficiency.
1. Java Garbage Collection for the Polyglot
Charlie Gracie, Garbage Collection Architect
Charlie_Gracie@ca.ibm.com
@crgracie
28 October 2015
What’s in an Object?
2. Who am I?
I have been working on the IBM J9 Virtual Machine since 2004
and I am currently the Garbage Collection Architect. J9 is
IBM's independent implementation of the JVM.
I have worked on almost all aspects of the J9 JVM including
garbage collection, core interpreter, RAS and L3 service.
My main focus areas have been improving garbage collection
scalability and de-coupling JVM components from the JVM
2
3. Important disclaimers
THE INFORMATION CONTAINED IN THIS PRESENTATION IS PROVIDED FOR INFORMATIONAL PURPOSES ONLY.
WHILST EFFORTS WERE MADE TO VERIFY THE COMPLETENESS AND ACCURACY OF THE INFORMATION
CONTAINED IN THIS PRESENTATION, IT IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED.
ALL PERFORMANCE DATA INCLUDED IN THIS PRESENTATION HAVE BEEN GATHERED IN A CONTROLLED
ENVIRONMENT. YOUR OWN TEST RESULTS MAY VARY BASED ON HARDWARE, SOFTWARE OR
INFRASTRUCTURE DIFFERENCES.
ALL DATA INCLUDED IN THIS PRESENTATION ARE MEANT TO BE USED ONLY AS A GUIDE.
IN ADDITION, THE INFORMATION CONTAINED IN THIS PRESENTATION IS BASED ON IBM’S CURRENT
PRODUCT PLANS AND STRATEGY, WHICH ARE SUBJECT TO CHANGE BY IBM, WITHOUT NOTICE.
IBM AND ITS AFFILIATED COMPANIES SHALL NOT BE RESPONSIBLE FOR ANY DAMAGES ARISING OUT
OF THE USE OF, OR OTHERWISE RELATED TO, THIS PRESENTATION OR ANY OTHER DOCUMENTATION.
NOTHING CONTAINED IN THIS PRESENTATION IS INTENDED TO, OR SHALL HAVE THE EFFECT OF:
– CREATING ANY WARRANT OR REPRESENTATION FROM IBM, ITS AFFILIATED COMPANIES OR ITS
OR THEIR SUPPLIERS AND/OR LICENSORS
3
10. No shared technology between runtimes
10
Effort in one runtime has no leverage in other runtimes
…looking very costly to support many language runtimes
11. Languages on the JVM
Leverage the investment in JVM by running on the JVM
– Cross platform support
– High performance runtime
– Production quality
– Tooling / monitoring support
– Interoperability with Java
11
12. Languages on the JVM
Works great for new languages like Scala and Groovy
Many existing languages have a vibrant non-JVM based community
– JVM implementation forks language and runtime communities
– Bridging the divide would mean migrating an entire community
Not all languages map nicely to Java semantics
We decided to experiment with a different approach that would allow
new and existing language communities to leverage JVM capabilities
12
13. 13
Announced by Mark Stoodley
at JVMLS 2015
See the complete talk here.
IBM is going to open source runtime technology
14. Our vision
Open community of contribution based around a toolkit of components that can be used to
build VMs for any language
Efficient place for individuals, communities, and companies to safely collaborate on core
VM infrastructure
Enable everyone to focus more energy on innovation, not on building more wheels
More robust core technology
– Fix bugs once
– Tested in many different scenarios
Collection of best practices and shared learning
Lower entry barrier for new languages and VM ideas
– Test ideas faster and more reliably
14
15. Unlock the VM from the JVM
Refactor J9 components to create a language-agnostic toolkit designed for
integration into language runtimes (including J9 JVM)
– Memory allocator, thread library, platform port library, event hook framework, VM and
application level trace engine, garbage collector, JIT compiler
Not a research project: out JDK product development team aggressively
refactoring our VM, GC, and JIT technology
– Shipped IBM JDK8 from snapshot of refactored code base
– JDK9 development ongoing as we continue to experiment
15
16. Transplant J9 Java capabilities to other runtimes
Common
utilities
Thread
library
Port
Library
Trace GC JIT
VM
Structures
…
Core
runtime
infrastructure
16
Tool
Agents
17. Integrate the toolkit
./configure the toolkit
– Select components and features
Copy generic language glue folder into the language
Provide implementation for the required language glue APIs
Call toolkit APIs from runtime
– Initialization, object allocation, file io, etc.
Compile and link the toolkit using makefiles provided
17
18. Language glue
Components are language agnostic
– Some operations still require language knowledge
Language glue is a set of API that answer questions about the language
Different components require different glue
18
23. Language agnostic garbage collection
Secret…. a lot of garbage collection operations use an opaque type
– Perform math on the actual pointer not the contents
mark map, card table, etc.
– Store a reference to the object
work stack, remembered set, etc.
23
24. Language agnostic garbage collection
What does the garbage collector need from the language?
– object size
– object shape / layout
Getting this information needs to be fast!!!
– iterating an objects references is on the hot path
24
25. Language agnostic garbage collection
Decoupled the garbage collector from J9 JVM
1. Using an opaque object type wherever possible
2. Defining glue API to answer language questions
Performance critical API implemented in hpp to ensure inlining
Investigating templates to improve iterating an objects references
25
26. Garbage collection features
1. Allocator, work stack, parallel operation intrinsics, etc.
2. Mark / sweep global collector
3. Compactor
4. Concurrent global collector
5. Generational copying collector
6. Compressed references
26
27. Garbage collection features
Pre/post calls for each garbage collection operation
– Allows the language to do any specific work it requires
By default these calls do nothing
Example
– When object marking is complete (all live objects found) Java needs to handle
finalizable objects
27
28. Integrate the garbage collector
Make this as easy as possible
Only require glue for enabled features
– Compile time flags control which features are enabled
Required glue API contain #error messages
– Missing implementations cause compile failures and not runtime failures
Provide detailed documentation and examples for glue
28
29. Integrate the garbage collector
1 day
– By default object allocation and single threaded mark / sweep is enabled
– ONLY 3 glue APIs to implement
3 days
– Enable parallelism and compaction
5 days
– Enable concurrent marking
7 days
– Enable generational collection
9 days
– Enable compressed references on 64 bit platforms
NOTE sample schedule for adding support
29
30. Testing the garbage collector
Simple C application to test garbage collector functionality
– Just need to provide the appropriate glue
Created a test framework to build object graphs
– Easy to write repeatable test cases
– Test performance of algorithm changes
No need to bring up the entire runtime to unit test the GC
Can force operations to happen in a particular order
– Very difficult to force operations when testing the whole system (a test written
in the language)
30
31. CSOM example
C implementation of Simple Object Machine (SOM)
SOM is a minimal Smalltalk used for teaching and research on VMs
“Clarity of implementation over absolute performance”
http://som-st.github.io/
https://github.com/SOM-st/CSOM
31
32. VM startup and shutdown
32
void Universe_initialize(int argc, const char** argv) {
Initialize_VM(&VM, &VMThread, …);
//complete the normal startup
…
Interpreter_start();
}
File: CSOM/src/vm/universe.c
33. VM startup and shutdown
33
void Universe_destruct(void) {
// complete normal CSOM destruction
…
Shutdown_VM(VM, VMThread);
}
File: CSOM/src/vm/universe.c
35. GC collection
35
void gc_collect() {
// delete CSOM collect code and call collection API
GC_GlobalCollect(FORCED_GLOBAL);
}
File: CSOM/src/memory/gc.c
36. Implement required glue
36
/**
* How big is this object
*/
uintptr_t getSizeInBytesWithHeader(objectptr_t objectPtr) {
// return object_size from som object
return ((pOOObject)objectPtr)->object_size;
}
File: CSOM/glue/ObjectModel.hpp
37. Implement required glue
37
/**
* Find all reference slots in objectPtr and call
* MM_MarkingScheme::markObject() on them
*/
void markingScheme_scanObject(objectptr_t objectPtr) {
// call actual CSOM function for marking on objects references
SEND((pVMObject)objectPtr, mark_references);
}
File: CSOM/glue/CollectorLanguageInterface.cpp
38. Implement required glue
38
extern “C” {
/**
* Provide implementation for function required by mark_references function
* in src/memory/gc.c
*/
void gc_mark_object(void *object) {
// use tls to get the current environment pointer since mark object does not pass it
MM_EnvironmentBase *env = getCurrentEnvironment();
MM_MarkingScheme *markingScheme = getMarkingScheme();
if (markingScheme->isHeapObject((objectptr_t)object)) {
markingScheme->markObject(env, (objectptr_t)object);
}
}
}
File: CSOM/glue/CollectorLanguageInterface.cpp
39. Implement required glue
39
/**
* This function is called by all worker threads. Be sure to
* use the synchronization APIs
*/
void markingScheme_scanRoots(MM_EnvironmentBase *env) {
// handle all roots with just one thread
if (env->_currentTask->synchronizeGCThreadsAndReleaseSingleThread(env, UNIQUE_ID)) {
// call actual CSOM function for marking roots
gc_mark_reachable_objects(); //<-- this function was not changes at all
env->_currentTask->releaseSyncrhonizedGCThreads(env);
}
}
File: CSOM/glue/CollectorLanguageInterface.cpp
40. CSOM results
With this small changeset you get
– Object allocation
– Parallel mark / sweep collector
– verbose:gc output which can be consumed by GCMV
Passes all CSOM tests and benchmarks
– Full benchmark suite is about 20% faster
40
43. Proof points
Integrated the toolkit into MRI and CPython
– JIT support
– Scalable garbage collection
– Monitoring tools
Our emphasis has been on compatibility
– Consistent behaviour for compiled code vs interpreted code
– No restrictions on native code used by extension modules
– All tests that ship with both languages continue to pass
– We can run Rails
43
44. JIT integration
Ruby MRI and CPython do not have JIT compilers
Both environments are challenging for JIT compilers
– Highly dynamic
– Unmanaged direct use of internal data structures by extensions
– Design choices in the runtimes themselves (e.g., setjmp/longjmp)
Our effort to date has particular emphases
– Compile native instructions for methods and blocksConsistent behavior for compiled code vs.
interpreted code
– No restrictions on native code used by extension modules
– No benchmark tuning or specials
Compatibility story: We can run Rails!
Performance story: 1.2x + on many Bench9k kernels on 3 architectures without tuning
44
45. Scalable garbage collection
Integrated GC into CPython and MRI
– Type accurate, but used conservatively so extensions work as-is
CPython investigating reference count improvements and/or removal
MRI can move off-heap native memory into manageable heap
– Provides performance improvement by moving data closer to objects
Perform mark and sweep operations in parallel
Verbose:gc and GCMV support out of the box
45
47. We are keen to hear your feedback
Early results are very promising
Next steps
– Open source components and features that are ready
– Balance refactoring work against improving proof points
– Engaging with communities and partners
Open request for feedback or interest to get involved!
47
Charlie Gracie Mark Stoodley John Duimovich
O/S GC Architect O/S Project Lead CTO, IBM Runtimes
charlie_gracie@ca.ibm.com mstoodle@ca.ibm.com john_duimovich@ca.ibm.com
48. More information
Daryl Maier - Wednesday, Oct 28, 1:00 p.m. | Hilton—Golden Gate 6/7/8
– Beyond the coffee cup: Leveraging Java Runtime Technologies for Polyglot [CON7547]
Follow us on twitter
– Charlie Gracie - @crgracie
– Daryl Maier - @0xdaryl
– Mark Stoodley - @mstoodle
48
50. 50
Legal Notice
IBM and the IBM logo are trademarks or registered trademarks of IBM Corporation, in the United States, other
countries or both.
Java and all Java-based marks, among others, are trademarks or registered trademarks of Oracle in the United
States, other countries or both.
Other company, product and service names may be trademarks or service marks of others.
THE INFORMATION DISCUSSED IN THIS PRESENTATION IS PROVIDED FOR INFORMATIONAL
PURPOSES ONLY. WHILE EFFORTS WERE MADE TO VERIFY THE COMPLETENESS AND
ACCURACY OF THE INFORMATION, IT IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, AND IBM SHALL NOT BE RESPONSIBLE FOR ANY DAMAGES ARISING OUT
OF THE USE OF, OR OTHERWISE RELATED TO, SUCH INFORMATION. ANY INFORMATION
CONCERNING IBM'S PRODUCT PLANS OR STRATEGY IS SUBJECT TO CHANGE BY IBM WITHOUT
NOTICE.
Editor's Notes
A little bit of background on me….
We start with our safe harbor slide that tells us basically, don’t trust anything I have to say.
Don’t worry, by the end of the conference, I’m sure we’ll be sick of these slides.
We are here at JavaOne because we all know and love Java.
Java is a stable, performant and scalable runtime.
It has decades of development into JIT, GC and other technologies
Over the last few years a lot of new languages are gaining traction.
With more and more applications moving to the cloud we see more developers requiring skills in more than one language
How many people work Ruby??? Python??? JavaScript???? As well as java
These languages all have their strengths and weaknesses
More than just learning the language developers need to know how to run, tune, profiling and debug all of these languages.
How do you configure options? How do you set the maximum size of the heap? Is there even a maximum size
IDE, profilers, monitoring agents?
"Groovy-logo" by Zorak1103 - Own work. Licensed under CC BY-SA 3.0 via Commons - https://commons.wikimedia.org/wiki/File:Groovy-logo.svg#/media/File:Groovy-logo.svg
If one language is updated to take advantage of a feature like transitional memory it does not help any of the other runtimes.
Another example would be platform support. Not all of these runtimes support and are optimized for platforms like arm or PPC.
Add support for method profiling and a tool to display it. Each language would do this themselves.
One solution would be to move all of these languages to run on the JVM
You get free platform support everywhere java is supported
With great JIT and GC technology
Production quality. There are thousands of applications running on java every day, many of which are running critical infrastructure
Scala and groovy were implemented on the JVM and work well with in the JVM consrtaints
The light blue components make up the core infrastructure that is required by the other feature components
The core infrastructure can be consumed on its own to provide a portability layer
Port library provides a platform agnostic API to get access to features like native memory allocation, file, io, etc
The feature components have no required dependencies on other feature components
You could just add the GC to your runtime or just add the JIT to another runtime
Components may have optional features you can use. GC component has features like mark/sweep, compaction, generational copying, concurrent marking, etc.
Sounds easy right?
What is the language glue?
This is the title of my talk.
The GC allocates memory for the language and the language fills in the data
What is the secret to decoupling our garbage collection technology from the JVM?
None of these operations actually need to know the contents of the object
With this little bit of data the GC can actually perform all of its required operations on objects
By default when you enable to GC component you get 1 and 2. As you enable the other features it will require more language glue
Also the language will have to obey components contracts by calling required APIs
An example of such a contract would be having an object write barrier so that the GC can track object references for genernational and concurrent collectors
All of the code for a feature is control via a compile time flag for that feature.
Allows you to easily sprinkle as little or as much GC on your language
3 API. Object size, scan object and mark roots
Language must implement object write barriers. Need the ability to track writes to objects
Generational collector requires per object flags. The language object will need to be instrumented to include space for these flags
Compaction and generational could only be supported if your language permits objects to move
Compressed references could only be supported if your language controls fetching a field from an object via APIs and not directly in any c-extension. Effectively requires an object read barrier
I would like to show you an example of integrating our portability layer and GC into CSOM
CSOM is the c implementation of SOM
SOM is minimal Smalltalk used for teaching
Clarity of implementation over absolute performance
Part of the core architecture was generic VM structures required by the feature components. That would be the VM and VMThread paramters. The Initialize_VM function creates and initializes all of the components configured to be used.
Part of the core architecture was generic VM structures required by the feature components. That would be the VM and VMThread paramters. The Initialize_VM function creates and initializes all of the components configured to be used.
CSOM relies on no GCs not interrupting certain operations. So if the free memory drops below the threshold and you are not in an uninterruptable state it forces a global collection.
Delete all of the collection code and directly call global collection API
Normally this would use an implementation of the ObjectSlotIterator which is part of the glue but to keep this simple I left it out
Normally this would use an implementation of the ObjectSlotIterator which is part of the glue but to keep this simple I left it out
CSOM provided this function which would mark the object as live and then call mark_references on itself.
Instead we just mark the object and let GC work stack handle processing marked objects
markObject will set a bit in the mark map for this object if it was not already marked and push it on the work stack to be processed.
I have the complete changesets from this example which will be available on my GITHUB account once the toolkit has been open sourced.
I will also be including the changes for adding compaction support and removing the requirement to not GC during object initialization
This was free. There were no changes for this.
This was free. There were no changes to the tool for this