The "n" in the PrintCompilation output indicates that the method was not compiled, but is on deck to be compiled. So in this case, java.lang.Object::hashCode was not yet compiled, but is a candidate for compilation if/when it is called more.
This document discusses intrinsic methods in the HotSpot JVM. It provides background on what intrinsic methods are and how they are implemented and optimized in JVMs and native compilers. It gives examples of intrinsic methods in HotSpot VM like System.currentTimeMillis(), Unsafe.compareAndSwapInt(), and Math.log(). It also discusses intrinsic methods added in TaobaoJDK like TCrc32 and how to experiment implementing your own intrinsic methods in the C1 and C2 compilers.
Kris Mok presented on customizing the JVM at Taobao to improve performance and diagnostics. Some key customizations discussed include:
1) Creating a GC Invisible Heap (GCIH) to improve performance by removing large static data from GC management.
2) Optimizing JNI wrappers to reduce overhead of JNI calls by handling common cases more efficiently.
3) Adding support for new instructions like CRC32c to take advantage of hardware acceleration.
4) Adding flags like -XX:+PrintGCReason to provide more information on the direct causes of GC cycles.
5) Tracking huge object and array allocations to help diagnose out of memory errors.
The document discusses just-in-time (JIT) compilers in the Java Virtual Machine (JVM). It describes how JIT compilers work by compiling bytecode to native machine code during execution based on profiling information. This allows for optimizations like inlining, devirtualization, loop unrolling and eliding unnecessary synchronization that improve performance. The JIT compiler uses feedback from profiling to enable more aggressive optimizations like these.
JVM JIT compilation overview by Vladimir IvanovZeroTurnaround
The document provides an overview of JVM JIT-compilers, including:
- JIT-compilers in the HotSpot JVM dynamically compile bytecode to native machine code during program execution for improved performance compared to interpretation alone.
- JIT-compilers use profiling information gathered during execution to perform aggressive optimizations like inlining and devirtualization.
- The monitoring and debugging of JIT-compilers in the HotSpot JVM can be done using options like -XX:+PrintCompilation, -XX:+PrintInlining, and -XX:+PrintAssembly.
Slides for my talk event-sourced architectures with Akka. Discusses Akka Persistence as mechanism to do event-sourcing. Presented at Javaone 2014 and Jfokus 2015.
The document discusses Coordinated Restore at Checkpoint (CRaC), a feature of the Java Virtual Machine (JVM) that allows saving the state of a running application and restoring it later to avoid JVM startup overhead. CRaC uses the CRIU userspace checkpoint/restore mechanism and provides a simple API for applications to register resources that need to be notified during checkpoint and restore. This allows restoring application state like open files and sockets. An example demonstrates how CRaC can speed up subsequent runs of an application by restoring a pre-filled cache from a previous checkpoint.
Secrets of Performance Tuning Java on KubernetesBruno Borges
Java on Kubernetes may seem complicated, but after a bit of YAML and Dockerfiles, you will wonder what all that fuss was. But then the performance of your app in 1 CPU/1 GB of RAM makes you wonder. Learn how JVM ergonomics, CPU throttling, and GCs can help increase performance while reducing costs.
The "n" in the PrintCompilation output indicates that the method was not compiled, but is on deck to be compiled. So in this case, java.lang.Object::hashCode was not yet compiled, but is a candidate for compilation if/when it is called more.
This document discusses intrinsic methods in the HotSpot JVM. It provides background on what intrinsic methods are and how they are implemented and optimized in JVMs and native compilers. It gives examples of intrinsic methods in HotSpot VM like System.currentTimeMillis(), Unsafe.compareAndSwapInt(), and Math.log(). It also discusses intrinsic methods added in TaobaoJDK like TCrc32 and how to experiment implementing your own intrinsic methods in the C1 and C2 compilers.
Kris Mok presented on customizing the JVM at Taobao to improve performance and diagnostics. Some key customizations discussed include:
1) Creating a GC Invisible Heap (GCIH) to improve performance by removing large static data from GC management.
2) Optimizing JNI wrappers to reduce overhead of JNI calls by handling common cases more efficiently.
3) Adding support for new instructions like CRC32c to take advantage of hardware acceleration.
4) Adding flags like -XX:+PrintGCReason to provide more information on the direct causes of GC cycles.
5) Tracking huge object and array allocations to help diagnose out of memory errors.
The document discusses just-in-time (JIT) compilers in the Java Virtual Machine (JVM). It describes how JIT compilers work by compiling bytecode to native machine code during execution based on profiling information. This allows for optimizations like inlining, devirtualization, loop unrolling and eliding unnecessary synchronization that improve performance. The JIT compiler uses feedback from profiling to enable more aggressive optimizations like these.
JVM JIT compilation overview by Vladimir IvanovZeroTurnaround
The document provides an overview of JVM JIT-compilers, including:
- JIT-compilers in the HotSpot JVM dynamically compile bytecode to native machine code during program execution for improved performance compared to interpretation alone.
- JIT-compilers use profiling information gathered during execution to perform aggressive optimizations like inlining and devirtualization.
- The monitoring and debugging of JIT-compilers in the HotSpot JVM can be done using options like -XX:+PrintCompilation, -XX:+PrintInlining, and -XX:+PrintAssembly.
Slides for my talk event-sourced architectures with Akka. Discusses Akka Persistence as mechanism to do event-sourcing. Presented at Javaone 2014 and Jfokus 2015.
The document discusses Coordinated Restore at Checkpoint (CRaC), a feature of the Java Virtual Machine (JVM) that allows saving the state of a running application and restoring it later to avoid JVM startup overhead. CRaC uses the CRIU userspace checkpoint/restore mechanism and provides a simple API for applications to register resources that need to be notified during checkpoint and restore. This allows restoring application state like open files and sockets. An example demonstrates how CRaC can speed up subsequent runs of an application by restoring a pre-filled cache from a previous checkpoint.
Secrets of Performance Tuning Java on KubernetesBruno Borges
Java on Kubernetes may seem complicated, but after a bit of YAML and Dockerfiles, you will wonder what all that fuss was. But then the performance of your app in 1 CPU/1 GB of RAM makes you wonder. Learn how JVM ergonomics, CPU throttling, and GCs can help increase performance while reducing costs.
This document discusses how the Java Virtual Machine (JVM) can support multiple languages. It describes how language features can be emulated on the JVM through additional layers of indirection. It outlines key features added in JDK 7 like invokedynamic bytecode and method handles to better support dynamic languages on the JVM by reducing overhead from emulation. The document argues that the JVM should optimize for non-Java language features to benefit both Java and other languages running on the platform.
Best Practices for the Most Impactful Oracle Database 18c and 19c FeaturesMarkus Michalewicz
Oracle OpenWorld 2019 featured a presentation on best practices for high availability (HA) features in Oracle Database versions 12c, 18c, and 19c. The presentation covered key HA capabilities like Oracle Multitenant and Pluggable Databases, Data Guard, Hang Manager, and Real Application Clusters. It provided an overview of how each feature enables common lifecycle operations and maintenance tasks to be performed with minimal downtime.
Wars of MySQL Cluster ( InnoDB Cluster VS Galera ) Mydbops
MySQL Clustering over InnoDB engines has grown a lot over the last decade. Galera began working with InnoDB early and then Group Replication came to the environment later, where the features are now rich and robust. This presentation offers a technical comparison of both of them.
The document discusses Linux memory management, describing how physical memory is divided into page frames and virtual memory allows processes to have a virtual view of memory mapped to physical memory using page tables, and covers topics like memory overcommit, page cache, swap space, and tools for monitoring memory usage.
syzkaller is an unsupervised, coverage-guided Linux syscall fuzzer.
The presentation covers basic of operation of the fuzzer, gives tutorial on how to run it and how to extend it to fuzz new drivers.
Oracle 12c RAC On your laptop Step by Step Implementation Guide 1.0Yury Velikanov
The document provides instructions for setting up a two-node Oracle 12c RAC environment within Oracle VirtualBox on a Windows laptop. The main steps include:
1. Configuring VirtualBox with a host-only network and installing Oracle Linux 6 on the first virtual machine.
2. Creating shared virtual disks for the ASM storage and installing Oracle Grid Infrastructure.
3. Cloning the first virtual machine to create the second node, and installing the Oracle 12c database software.
This allows users to test an Oracle 12c RAC sandbox environment locally without requiring additional physical hardware.
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVMJonas Bonér
My talk for JavaOne 2009
Abstract:
Writing concurrent programs in the Java programming language is hard, and writing correct concurrent programs is even harder. What should be noted is that the main problem is not concurrency itself but the use of mutable shared state. Reasoning about concurrent updates to, and guarding of, mutable shared state is extremely difficult. It imposes problems such as dealing with race conditions, deadlocks, live locks, thread starvation, and the like.
It might come as a surprise to some people, but there are alternatives to so-called shared-state concurrency (which has been adopted by C, C++, and the Java programming language and become the default industry-standard way of dealing with concurrency problems).
This session discusses the importance of immutability and explores alternative paradigms such as dataflow concurrency, message-passing concurrency, and software transactional memory. It includes a pragmatic discussion of the drawbacks and benefits of each paradigm and, through hands-on examples, shows you how each one, in its own way, can raise the abstraction level and give you a model that is much easier to reason about and use. The presentation also shows you how, by choosing the right abstractions and technologies, you can make hard concurrency problems close to trivial. All discussions are driven by examples using state-of-the-art implementations available for the JVM machine.
This document discusses PostgreSQL database architecture patterns for running PostgreSQL at scale when a relational database as a service like Amazon RDS won't meet needs. It describes challenges faced with MySQL, Redshift and Vertica and how PostgreSQL was better suited through techniques like partitioning by date, TOAST compression, foreign data wrappers, and poor man's parallel processing. Key takeaways are that PostgreSQL supported scaling to petabytes of data, sub-second queries across large date ranges, and custom extensions needed while avoiding limitations and expenses of other database options.
Основные темы, затронутые на семинаре:
Задачи и компоненты подсистемы управления памятью;
Аппаратные возможности платформы x86_64;
Как описывается в ядре физическая и виртуальная память;
API подсистемы управления памятью;
Высвобождение ранее занятой памяти;
Инструменты мониторинга;
Memory Cgroups;
Compaction — дефрагментация физической памяти.
Oracle is planning to release Oracle Database 12c in calendar year 2013. The new release will include a multitenant architecture that allows for multiple pluggable databases to be consolidated and managed within a single container database. This new architecture enables fast provisioning of new databases, efficient cloning of pluggable databases, simplified patching and upgrades applied commonly to all pluggable databases, and other benefits that improve database consolidation on cloud platforms.
The Java Virtual Machine (JVM) can deliver significantly better performance through the use of Just In Time compilation. However, each time you start an application it needs to repeat the same process of analysis and compilation. This session discusses Java with Co-ordinated Checkpoint at Restore. This is a way to freeze an application and start it again (potentially many times) from the same checkpoint.
Meta/Facebook's database serving social workloads is running on top of MyRocks (MySQL on RocksDB). This means our performance and reliability depends a lot on RocksDB. Not just MyRocks, but also we have other important systems running on top of RocksDB. We have learned many lessons from operating and debugging RocksDB at scale.
In this session, we will offer an overview of RocksDB, key differences from InnoDB, and share a few interesting lessons learned from production.
JVM Mechanics: Understanding the JIT's TricksDoug Hawkins
In this talk, we'll walkthrough how the JIT optimizes a piece Java code step-by-step. In doing so, you'll learn some of the amazing feats of optimization that JVMs can perform, but also some surprisingly simple things that prevent your code from running fast.
In this session, you'll learn how RBD works, including how it:
Uses RADOS classes to make access easier from user space and within the Linux kernel.
Implements thin provisioning.
Builds on RADOS self-managed snapshots for cloning and differential backups.
Increases performance with caching of various kinds.
Uses watch/notify RADOS primitives to handle online management operations.
Integrates with QEMU, libvirt, and OpenStack.
G1 Garbage Collector: Details and TuningSimone Bordet
This document provides an overview and details about the G1 garbage collector in Java. It begins with introductions of the author and an overview of G1. Key points include that G1 is designed to provide low pause times, works well with large heap sizes, and will become the default collector in JDK 9. The document then discusses various aspects of G1 including its memory layout using regions, young generation collection, remembered set and write barrier for tracking references, and concurrent marking approach for old generation collection. It provides advice on G1 logging, tuning and common issues. An example migration from CMS to G1 for an online chess application is also summarized.
Clean Architecture promove a independência entre as camadas de uma aplicação, dividindo-a em Entidades, Casos de Uso, Controller e Frameworks & Drivers. Isso permite que cada camada seja testada e desenvolvida isoladamente. A arquitetura é demonstrada em Go com pacotes para Entidades, Interface, Serviço, Repositórios e API, permitindo testes por camada.
The document provides an overview of implementing a high-performance JavaScript engine. It discusses the key components including the parser, runtime, execution engine, garbage collector, and foreign function interface. It also covers various implementation strategies and tradeoffs for aspects like value representation, object models, execution engines, and garbage collection. The document emphasizes learning from Self VM and using techniques like hidden classes, inline caching, and tiered compilation and optimization.
This document discusses how the Java Virtual Machine (JVM) can support multiple languages. It describes how language features can be emulated on the JVM through additional layers of indirection. It outlines key features added in JDK 7 like invokedynamic bytecode and method handles to better support dynamic languages on the JVM by reducing overhead from emulation. The document argues that the JVM should optimize for non-Java language features to benefit both Java and other languages running on the platform.
Best Practices for the Most Impactful Oracle Database 18c and 19c FeaturesMarkus Michalewicz
Oracle OpenWorld 2019 featured a presentation on best practices for high availability (HA) features in Oracle Database versions 12c, 18c, and 19c. The presentation covered key HA capabilities like Oracle Multitenant and Pluggable Databases, Data Guard, Hang Manager, and Real Application Clusters. It provided an overview of how each feature enables common lifecycle operations and maintenance tasks to be performed with minimal downtime.
Wars of MySQL Cluster ( InnoDB Cluster VS Galera ) Mydbops
MySQL Clustering over InnoDB engines has grown a lot over the last decade. Galera began working with InnoDB early and then Group Replication came to the environment later, where the features are now rich and robust. This presentation offers a technical comparison of both of them.
The document discusses Linux memory management, describing how physical memory is divided into page frames and virtual memory allows processes to have a virtual view of memory mapped to physical memory using page tables, and covers topics like memory overcommit, page cache, swap space, and tools for monitoring memory usage.
syzkaller is an unsupervised, coverage-guided Linux syscall fuzzer.
The presentation covers basic of operation of the fuzzer, gives tutorial on how to run it and how to extend it to fuzz new drivers.
Oracle 12c RAC On your laptop Step by Step Implementation Guide 1.0Yury Velikanov
The document provides instructions for setting up a two-node Oracle 12c RAC environment within Oracle VirtualBox on a Windows laptop. The main steps include:
1. Configuring VirtualBox with a host-only network and installing Oracle Linux 6 on the first virtual machine.
2. Creating shared virtual disks for the ASM storage and installing Oracle Grid Infrastructure.
3. Cloning the first virtual machine to create the second node, and installing the Oracle 12c database software.
This allows users to test an Oracle 12c RAC sandbox environment locally without requiring additional physical hardware.
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVMJonas Bonér
My talk for JavaOne 2009
Abstract:
Writing concurrent programs in the Java programming language is hard, and writing correct concurrent programs is even harder. What should be noted is that the main problem is not concurrency itself but the use of mutable shared state. Reasoning about concurrent updates to, and guarding of, mutable shared state is extremely difficult. It imposes problems such as dealing with race conditions, deadlocks, live locks, thread starvation, and the like.
It might come as a surprise to some people, but there are alternatives to so-called shared-state concurrency (which has been adopted by C, C++, and the Java programming language and become the default industry-standard way of dealing with concurrency problems).
This session discusses the importance of immutability and explores alternative paradigms such as dataflow concurrency, message-passing concurrency, and software transactional memory. It includes a pragmatic discussion of the drawbacks and benefits of each paradigm and, through hands-on examples, shows you how each one, in its own way, can raise the abstraction level and give you a model that is much easier to reason about and use. The presentation also shows you how, by choosing the right abstractions and technologies, you can make hard concurrency problems close to trivial. All discussions are driven by examples using state-of-the-art implementations available for the JVM machine.
This document discusses PostgreSQL database architecture patterns for running PostgreSQL at scale when a relational database as a service like Amazon RDS won't meet needs. It describes challenges faced with MySQL, Redshift and Vertica and how PostgreSQL was better suited through techniques like partitioning by date, TOAST compression, foreign data wrappers, and poor man's parallel processing. Key takeaways are that PostgreSQL supported scaling to petabytes of data, sub-second queries across large date ranges, and custom extensions needed while avoiding limitations and expenses of other database options.
Основные темы, затронутые на семинаре:
Задачи и компоненты подсистемы управления памятью;
Аппаратные возможности платформы x86_64;
Как описывается в ядре физическая и виртуальная память;
API подсистемы управления памятью;
Высвобождение ранее занятой памяти;
Инструменты мониторинга;
Memory Cgroups;
Compaction — дефрагментация физической памяти.
Oracle is planning to release Oracle Database 12c in calendar year 2013. The new release will include a multitenant architecture that allows for multiple pluggable databases to be consolidated and managed within a single container database. This new architecture enables fast provisioning of new databases, efficient cloning of pluggable databases, simplified patching and upgrades applied commonly to all pluggable databases, and other benefits that improve database consolidation on cloud platforms.
The Java Virtual Machine (JVM) can deliver significantly better performance through the use of Just In Time compilation. However, each time you start an application it needs to repeat the same process of analysis and compilation. This session discusses Java with Co-ordinated Checkpoint at Restore. This is a way to freeze an application and start it again (potentially many times) from the same checkpoint.
Meta/Facebook's database serving social workloads is running on top of MyRocks (MySQL on RocksDB). This means our performance and reliability depends a lot on RocksDB. Not just MyRocks, but also we have other important systems running on top of RocksDB. We have learned many lessons from operating and debugging RocksDB at scale.
In this session, we will offer an overview of RocksDB, key differences from InnoDB, and share a few interesting lessons learned from production.
JVM Mechanics: Understanding the JIT's TricksDoug Hawkins
In this talk, we'll walkthrough how the JIT optimizes a piece Java code step-by-step. In doing so, you'll learn some of the amazing feats of optimization that JVMs can perform, but also some surprisingly simple things that prevent your code from running fast.
In this session, you'll learn how RBD works, including how it:
Uses RADOS classes to make access easier from user space and within the Linux kernel.
Implements thin provisioning.
Builds on RADOS self-managed snapshots for cloning and differential backups.
Increases performance with caching of various kinds.
Uses watch/notify RADOS primitives to handle online management operations.
Integrates with QEMU, libvirt, and OpenStack.
G1 Garbage Collector: Details and TuningSimone Bordet
This document provides an overview and details about the G1 garbage collector in Java. It begins with introductions of the author and an overview of G1. Key points include that G1 is designed to provide low pause times, works well with large heap sizes, and will become the default collector in JDK 9. The document then discusses various aspects of G1 including its memory layout using regions, young generation collection, remembered set and write barrier for tracking references, and concurrent marking approach for old generation collection. It provides advice on G1 logging, tuning and common issues. An example migration from CMS to G1 for an online chess application is also summarized.
Clean Architecture promove a independência entre as camadas de uma aplicação, dividindo-a em Entidades, Casos de Uso, Controller e Frameworks & Drivers. Isso permite que cada camada seja testada e desenvolvida isoladamente. A arquitetura é demonstrada em Go com pacotes para Entidades, Interface, Serviço, Repositórios e API, permitindo testes por camada.
The document provides an overview of implementing a high-performance JavaScript engine. It discusses the key components including the parser, runtime, execution engine, garbage collector, and foreign function interface. It also covers various implementation strategies and tradeoffs for aspects like value representation, object models, execution engines, and garbage collection. The document emphasizes learning from Self VM and using techniques like hidden classes, inline caching, and tiered compilation and optimization.
The document discusses Java class and method data structures stored in the permanent generation area of memory. It describes the fields within the Klass, instanceKlass, and methodOopDesc structures that represent classes and methods. It also discusses full garbage collection and minor garbage collection stack traces.
Lambdas and streams are key new features in Java 8. Lambdas allow blocks of code to be passed around as if they were objects. Streams provide an abstraction for processing collections of objects in a declarative way using lambdas. Optional is a new class that represents null-safe references and helps avoid null pointer exceptions. Checked exceptions can cause issues with lambdas, so helper methods are recommended to convert checked exceptions to unchecked exceptions.
Check out my blog : https://oalieno.github.io/2019/06/07/security/pwn/rootkit/
Introduction and implementation of rootkit. Targeting linux kernel 5.x.x.
This presentation covers the flow of Zend optimizer for PHP and the approaches to accelerate PHP execution by introducing LLVM compiler infrastructure.