This document discusses Java garbage collection statistics and performance analysis. It provides an overview of Java heap memory management and minor and major garbage collection. It then describes how to generate simple garbage collection data using Java command line options, isolate the data using regular expressions, graph the data in a spreadsheet to visualize heap usage over time, and interpret the graphs to understand application behavior and identify opportunities to improve performance. More advanced garbage collection statistics are also discussed that provide additional heap memory usage details before and after each collection.
Apply Hammer Directly to Thumb; Avoiding Apache Spark and Cassandra AntiPatt...Databricks
Learn from someone who has made just about every basic Apache Spark mistake possible so you don’t have to! We’ll go over some of the most common things that users do that end up doing that cause unnecessary pain and actually explain how to avoid them.
Confused about serialization? Not sure what is meant by use a singleton to share connections? Together we will walk through concrete examples of how to handle these situation. Learn how to: do all your work remotely, not break your catalyst optimizations, use all your resources, and much more! Together lets learn how to make our Spark Applications better!
2014-06-20 Multinomial Logistic Regression with Apache SparkDB Tsai
Logistic Regression can not only be used for modeling binary outcomes but also multinomial outcome with some extension. In this talk, DB will talk about basic idea of binary logistic regression step by step, and then extend to multinomial one. He will show how easy it's with Spark to parallelize this iterative algorithm by utilizing the in-memory RDD cache to scale horizontally (the numbers of training data.) However, there is mathematical limitation on scaling vertically (the numbers of training features) while many recent applications from document classification and computational linguistics are of this type. He will talk about how to address this problem by L-BFGS optimizer instead of Newton optimizer.
Bio:
DB Tsai is a machine learning engineer working at Alpine Data Labs. He is recently working with Spark MLlib team to add support of L-BFGS optimizer and multinomial logistic regression in the upstream. He also led the Apache Spark development at Alpine Data Labs. Before joining Alpine Data labs, he was working on large-scale optimization of optical quantum circuits at Stanford as a PhD student.
Extending Spark SQL API with Easier to Use Array Types Operations with Marek ...Databricks
Big companies typically integrate their data from various heterogeneous systems when building a data lake as single point for accessing data. To achieve this goal technical teams often deal with data defined by complex schemas and various data formats. Spark SQL Datasets are currently compatible with data formats such as XML, Avro and Parquet by providing primitive and complex data types such as structs and arrays.
Although Dataset API offers rich set of functions, general manipulation of array and deeply nested data structures is lacking. We will demonstrate this fact by providing examples of data which is currently very hard to process in Spark efficiently. We designed and developed an extension of Dataset API to allow developers to work with array and complex type elements in a more straightforward and consistent way. The extension should help users dealing with complex and structured big data to use Apache Spark as a truly generic processing framework.
Multinomial Logistic Regression with Apache SparkDB Tsai
Logistic Regression can not only be used for modeling binary outcomes but also multinomial outcome with some extension. In this talk, DB will talk about basic idea of binary logistic regression step by step, and then extend to multinomial one. He will show how easy it's with Spark to parallelize this iterative algorithm by utilizing the in-memory RDD cache to scale horizontally (the numbers of training data.) However, there is mathematical limitation on scaling vertically (the numbers of training features) while many recent applications from document classification and computational linguistics are of this type. He will talk about how to address this problem by L-BFGS optimizer instead of Newton optimizer.
Bio:
DB Tsai is a machine learning engineer working at Alpine Data Labs. He is recently working with Spark MLlib team to add support of L-BFGS optimizer and multinomial logistic regression in the upstream. He also led the Apache Spark development at Alpine Data Labs. Before joining Alpine Data labs, he was working on large-scale optimization of optical quantum circuits at Stanford as a PhD student.
Description of the Reactive Collections framework for event-driven, reactive and distributed programming, and the real-time game engine use case. See the game demos on YouTube:
http://www.youtube.com/channel/UCoyqnhi_BdpLrBVMvkNIMMw
Apply Hammer Directly to Thumb; Avoiding Apache Spark and Cassandra AntiPatt...Databricks
Learn from someone who has made just about every basic Apache Spark mistake possible so you don’t have to! We’ll go over some of the most common things that users do that end up doing that cause unnecessary pain and actually explain how to avoid them.
Confused about serialization? Not sure what is meant by use a singleton to share connections? Together we will walk through concrete examples of how to handle these situation. Learn how to: do all your work remotely, not break your catalyst optimizations, use all your resources, and much more! Together lets learn how to make our Spark Applications better!
2014-06-20 Multinomial Logistic Regression with Apache SparkDB Tsai
Logistic Regression can not only be used for modeling binary outcomes but also multinomial outcome with some extension. In this talk, DB will talk about basic idea of binary logistic regression step by step, and then extend to multinomial one. He will show how easy it's with Spark to parallelize this iterative algorithm by utilizing the in-memory RDD cache to scale horizontally (the numbers of training data.) However, there is mathematical limitation on scaling vertically (the numbers of training features) while many recent applications from document classification and computational linguistics are of this type. He will talk about how to address this problem by L-BFGS optimizer instead of Newton optimizer.
Bio:
DB Tsai is a machine learning engineer working at Alpine Data Labs. He is recently working with Spark MLlib team to add support of L-BFGS optimizer and multinomial logistic regression in the upstream. He also led the Apache Spark development at Alpine Data Labs. Before joining Alpine Data labs, he was working on large-scale optimization of optical quantum circuits at Stanford as a PhD student.
Extending Spark SQL API with Easier to Use Array Types Operations with Marek ...Databricks
Big companies typically integrate their data from various heterogeneous systems when building a data lake as single point for accessing data. To achieve this goal technical teams often deal with data defined by complex schemas and various data formats. Spark SQL Datasets are currently compatible with data formats such as XML, Avro and Parquet by providing primitive and complex data types such as structs and arrays.
Although Dataset API offers rich set of functions, general manipulation of array and deeply nested data structures is lacking. We will demonstrate this fact by providing examples of data which is currently very hard to process in Spark efficiently. We designed and developed an extension of Dataset API to allow developers to work with array and complex type elements in a more straightforward and consistent way. The extension should help users dealing with complex and structured big data to use Apache Spark as a truly generic processing framework.
Multinomial Logistic Regression with Apache SparkDB Tsai
Logistic Regression can not only be used for modeling binary outcomes but also multinomial outcome with some extension. In this talk, DB will talk about basic idea of binary logistic regression step by step, and then extend to multinomial one. He will show how easy it's with Spark to parallelize this iterative algorithm by utilizing the in-memory RDD cache to scale horizontally (the numbers of training data.) However, there is mathematical limitation on scaling vertically (the numbers of training features) while many recent applications from document classification and computational linguistics are of this type. He will talk about how to address this problem by L-BFGS optimizer instead of Newton optimizer.
Bio:
DB Tsai is a machine learning engineer working at Alpine Data Labs. He is recently working with Spark MLlib team to add support of L-BFGS optimizer and multinomial logistic regression in the upstream. He also led the Apache Spark development at Alpine Data Labs. Before joining Alpine Data labs, he was working on large-scale optimization of optical quantum circuits at Stanford as a PhD student.
Description of the Reactive Collections framework for event-driven, reactive and distributed programming, and the real-time game engine use case. See the game demos on YouTube:
http://www.youtube.com/channel/UCoyqnhi_BdpLrBVMvkNIMMw
Photo-realistic Single Image Super-resolution using a Generative Adversarial ...Hansol Kang
* Ledig, Christian, et al. "Photo-realistic single image super-resolution using a generative adversarial network." Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.
Scaling out logistic regression with SparkBarak Gitsis
Large scale multinomial logistic regression with Spark. Contains animated gifs. Analysis of LBFGS. Real world spark configurations. SimilarWeb categorization algorithm
Practical and Worst-Case Efficient ApportionmentRaphael Reitzig
Proportional apportionment is the problem of assigning seats to parties according to their relative share of votes. Divisor methods are the de-facto standard solution, used in many countries.
In recent literature, there are two algorithms that implement divisor methods: one by Cheng and Eppstein (ISAAC, 2014) has worst-case optimal running time but is complex, while the other (Pukelsheim, 2014) is relatively simple and fast in practice but does not offer worst-case guarantees.
This talk presents the ideas behind a novel algorithm that avoids the shortcomings of both. We investigate the three contenders in order to determine which is most useful in practice.
Read more over here: http://reitzig.github.io/publications/RW2015b
Query optimizers and people have one thing in common: the better they understand their data, the better they can do their jobs. Optimizing queries is hard if you don't have good estimates for the sizes of the intermediate join and aggregate results. Data profiling is a technique that scans data, looking for patterns within the data such as keys, functional dependencies, and correlated columns. These richer statistics can be used in Apache Calcite's query optimizer, and the projects that use it, such as Apache Hive, Phoenix and Drill. We describe how we built a data profiler as a table function in Apache Calcite, review the recent research and algorithms that made it possible, and show how you can use the profiler to improve the quality of your data.
A talk given by Julian Hyde at Apache: Big Data, Miami, on May 16th 2017.
From Java Code to Java Heap: Understanding the Memory Usage of Your App - Ch...jaxLondonConference
Presented at JAX London 2013
When you write and run Java code, the JVM makes several allocations on your behalf, but do you have an understanding of how much that is? This session provides insight into the memory usage of Java code, covering the memory overhead of putting int into an integer object and the cost of object delegation and the memory efficiency of the different collection types. It also gives you an understanding of the off-Java (native) heap memory usage of some types of Java objects, such as threads and sockets.
Java Garbage Collectors – Moving to Java7 Garbage First (G1) CollectorGurpreet Sachdeva
One of the key strengths of JVM is automatic memory management (Garbage Collection). Its understanding can help in writing better applications. This becomes all the more important as enterprise server applications have large amount of live heap data and significant parallel threads. Until recently, main collectors were parallel collector and concurrent-mark-sweep (CMS) collector. This presentation introduces the various Garbage Collectors and compares the CMS collector against its replacement, a new implementation in Java7 i.e. G1. It is characterized by a single contiguous heap which is split into same-sized regions. In fact if your application is still running on the 1.5 or 1.6 JVM, a compelling argument to upgrade to Java 7 is to leverage G1.
Performance van Java 8 en verder - Jeroen BorgersNLJUG
We weten allemaal dat de grootste verbetering die Java 8 brengt de ondersteuning voor lambda-expressies is. Dit introduceert functioneel programmeren in Java. Door het toevoegen van de Stream API wordt deze verbetering nog groter: iteratie kan nu intern worden afgehandeld door een bibliotheek, je kunt daarmee nu het beginsel "Tell, don’t ask" toepassen op collecties. Je kunt gewoon vertellen dat er een ??functie uitgevoerd moet worden op je verzameling, of vertellen dat dat parallel, door meerdere cores moet gebeuren. Maar wat betekent dit voor de prestaties van onze Java-toepassingen? Kunnen we nu meteen volledig al onze CPU-cores benutten om betere responstijden te krijgen? Hoe werken filter / map / reduce en parallele streams precies intern? Hoe wordt het Fork-Join framework hierin gebruikt? Zijn lambda's sneller dan inner klassen? - Al deze vragen worden beantwoord in deze sessie. Daarnaast introduceert Java 8 meer performance verbeteringen: tiered compilatie, PermGen verwijdering, java.time, Accumulators, Adders en Map verbeteringen. Ten slotte zullen we ook een kijkje nemen in de keuken van de geplande performance verbeteringen voor Java 9: benutting van GPU's, Value Types en arrays 2.0.
From Java code to Java heap: Understanding and optimizing your application's ...Chris Bailey
This presentation gives you insight into the memory usage of Java™ code, covering the memory overhead of putting an int value into an Integer object, the cost of object delegation, and the memory efficiency of the different collection types. You'll learn how to determine where inefficiencies occur in your application and how to choose the right collections to improve your code.
You can read an article relating to the slides here:
http://www.ibm.com/developerworks/java/library/j-codetoheap/index.html
Photo-realistic Single Image Super-resolution using a Generative Adversarial ...Hansol Kang
* Ledig, Christian, et al. "Photo-realistic single image super-resolution using a generative adversarial network." Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.
Scaling out logistic regression with SparkBarak Gitsis
Large scale multinomial logistic regression with Spark. Contains animated gifs. Analysis of LBFGS. Real world spark configurations. SimilarWeb categorization algorithm
Practical and Worst-Case Efficient ApportionmentRaphael Reitzig
Proportional apportionment is the problem of assigning seats to parties according to their relative share of votes. Divisor methods are the de-facto standard solution, used in many countries.
In recent literature, there are two algorithms that implement divisor methods: one by Cheng and Eppstein (ISAAC, 2014) has worst-case optimal running time but is complex, while the other (Pukelsheim, 2014) is relatively simple and fast in practice but does not offer worst-case guarantees.
This talk presents the ideas behind a novel algorithm that avoids the shortcomings of both. We investigate the three contenders in order to determine which is most useful in practice.
Read more over here: http://reitzig.github.io/publications/RW2015b
Query optimizers and people have one thing in common: the better they understand their data, the better they can do their jobs. Optimizing queries is hard if you don't have good estimates for the sizes of the intermediate join and aggregate results. Data profiling is a technique that scans data, looking for patterns within the data such as keys, functional dependencies, and correlated columns. These richer statistics can be used in Apache Calcite's query optimizer, and the projects that use it, such as Apache Hive, Phoenix and Drill. We describe how we built a data profiler as a table function in Apache Calcite, review the recent research and algorithms that made it possible, and show how you can use the profiler to improve the quality of your data.
A talk given by Julian Hyde at Apache: Big Data, Miami, on May 16th 2017.
From Java Code to Java Heap: Understanding the Memory Usage of Your App - Ch...jaxLondonConference
Presented at JAX London 2013
When you write and run Java code, the JVM makes several allocations on your behalf, but do you have an understanding of how much that is? This session provides insight into the memory usage of Java code, covering the memory overhead of putting int into an integer object and the cost of object delegation and the memory efficiency of the different collection types. It also gives you an understanding of the off-Java (native) heap memory usage of some types of Java objects, such as threads and sockets.
Java Garbage Collectors – Moving to Java7 Garbage First (G1) CollectorGurpreet Sachdeva
One of the key strengths of JVM is automatic memory management (Garbage Collection). Its understanding can help in writing better applications. This becomes all the more important as enterprise server applications have large amount of live heap data and significant parallel threads. Until recently, main collectors were parallel collector and concurrent-mark-sweep (CMS) collector. This presentation introduces the various Garbage Collectors and compares the CMS collector against its replacement, a new implementation in Java7 i.e. G1. It is characterized by a single contiguous heap which is split into same-sized regions. In fact if your application is still running on the 1.5 or 1.6 JVM, a compelling argument to upgrade to Java 7 is to leverage G1.
Performance van Java 8 en verder - Jeroen BorgersNLJUG
We weten allemaal dat de grootste verbetering die Java 8 brengt de ondersteuning voor lambda-expressies is. Dit introduceert functioneel programmeren in Java. Door het toevoegen van de Stream API wordt deze verbetering nog groter: iteratie kan nu intern worden afgehandeld door een bibliotheek, je kunt daarmee nu het beginsel "Tell, don’t ask" toepassen op collecties. Je kunt gewoon vertellen dat er een ??functie uitgevoerd moet worden op je verzameling, of vertellen dat dat parallel, door meerdere cores moet gebeuren. Maar wat betekent dit voor de prestaties van onze Java-toepassingen? Kunnen we nu meteen volledig al onze CPU-cores benutten om betere responstijden te krijgen? Hoe werken filter / map / reduce en parallele streams precies intern? Hoe wordt het Fork-Join framework hierin gebruikt? Zijn lambda's sneller dan inner klassen? - Al deze vragen worden beantwoord in deze sessie. Daarnaast introduceert Java 8 meer performance verbeteringen: tiered compilatie, PermGen verwijdering, java.time, Accumulators, Adders en Map verbeteringen. Ten slotte zullen we ook een kijkje nemen in de keuken van de geplande performance verbeteringen voor Java 9: benutting van GPU's, Value Types en arrays 2.0.
From Java code to Java heap: Understanding and optimizing your application's ...Chris Bailey
This presentation gives you insight into the memory usage of Java™ code, covering the memory overhead of putting an int value into an Integer object, the cost of object delegation, and the memory efficiency of the different collection types. You'll learn how to determine where inefficiencies occur in your application and how to choose the right collections to improve your code.
You can read an article relating to the slides here:
http://www.ibm.com/developerworks/java/library/j-codetoheap/index.html
Azul Product Manager Matt Schuetze's presentation on JVM memory details to the Philadelphia Java User Group.
This session dovetails with the March, 2014 PhillyJUG deep dive session topic focused on Java compiler code transformation and JVM runtime execution. That session exposes myths that Java is slow and Java uses too much memory. In this session we will take a deeper look at Java memory management. The dreaded Out of Memory (OOM) error is one problem. Garbage collector activity and spikes leading to long pauses is another. He covers the foundations of garbage collection and why historically Java gets a bad rap, even though GC provides a marvelous memory management paradigm.
Memory Management: What You Need to Know When Moving to Java 8AppDynamics
This presentation will compare and contrast application behavior in Java 7 with Java 8, particularly focusing on memory management and usage. Several code examples are presented to show how to recognize and respond to common pitfalls.
Java Performance Fundamental 세미나 교재입니다. 3장은 Garbage Collection에 대해 설명하고 있습니다. 먼저 JVM에서 사용하는 Garbage Collection 뿐만 아니라 일반적인 Garbage Collection의 Algorithm을 상세히 알아봅니다. 그 후 Hotspot JVM의 Heap구조와 Garbage Collector를 설명하고 Generation별로 어떻게 동작하는 지에 대해 설명합니다. 이어 IBM JVM에 대한 Heap 구조와 Garbage Collector에 대해서도 설명합니다.
* Garbage Collection 이란?
* Garbage Collection 의 대상
* Garbage Collection 의 기본 Algorithm
* Hotspot JVM의 Garbage Collection
o Serial Collector
o Incremental Collector
o Parallel Collector
o CMS Collector
o Parallel Compaction Collector
o Garbage First Collector
* IBM JVM의 Garbage Collection
o Optimize for Throughput Collector
o Optimize for Pause Time Collector
o Generational Concurrent Collector
o Subpool Collector
With Java 8 released in March 2014, Oracle Java Technology Ambassador James Weaver discusses many of its new features such as lambda expressions, the stream API, and client-side capabilities with the JavaFX library.
Java SE 8 has brought lambdas, default methods, type annotations, compact profiles, etc. As a result, the Java SE platform specification was changed to reflect new features.
The session shows how the new Java 8 features have been implemented in Excelsior JET JVM, written from scratch, very different from the Oracle HotSpot JVM, but compatible with the Java SE specification.
As a result, an attendee will refresh his/her memory regarding new Java 8 features, will learn how they affected the JVM specification, how the lambda expressions are translated into Java bytecode and how they can be optimized at the JVM level.
Since JDK 9, G1 GC is the default garbage collector (JEP 248). Up until 2017, Monica has shared some G1 GC details, performance tips, and optimizations that help G1's adaptiveness and provided advice on manual tuning.
Since then, G1 has come a long way in improving its adaptiveness. In this session, Monica will cover most of the important optimizations that are delivered from JDK9+ and how they can help your application's responsiveness, throughput, and help with footprint reduction. This is a saga that involves various regions and generations (all pun intended).
This presentation is primarily based on Oracle's "Java SE 6 HotSpot™ Virtual Machine Garbage Collection Tuning" document.
This introduces how Java manages memory using generations, available garbage collectors and how to tune them to achieve desired performance.
Slides of my talk at QCon Hangzhou 2011, on the things that my team has been doing on the JVM, esp. on customization. Video available at http://www.infoq.com/cn/presentations/ms-jvm-taobao
Garbage First Garbage Collector (G1 GC): Current and Future Adaptability and ...Monica Beckwith
G1 GC Presentation @ JavaOne 2013
Sneak a peek under the hood of the latest and coolest garbage collector, Garbage-First!
Dive deep into G1's adaptability and ergonomics
Discuss the future of G1's adaptability
G1 Garbage Collector - Big Heaps and Low Pauses?C2B2 Consulting
Devoxx 2012 talk by Jaromir Hamala, C2B2 Senior Consultant.
The Garbage-First (G1) is the latest garbage collector in the JVM, aiming to be the long-term replacement for CMS. Targeted for machines with large memories and multiple processors. Promising low and more predictable pause times while achieving high throughput.
The session will introduce the architecture and design of G1. Then the main focus of the talk will be the performance characteristics observed under different loads; tuning capabilities and common pitfalls. With the aim of answering the question can you run big heaps and achieve low pauses.
Abstract: Nowadays it’s only a lazy one who haven’t written his own metric storage and aggregation system. I am lazy, and that’s why I have to choose what to use and how to use. I don’t want you to do the same job, so I decided to share my considerations concerning architectures and test results.
In Java 9, Garbage First Garbage Collector (G1 GC) will be the default GC. This presentation makes an effort to help Hotspot VM users to understand the concept of G1 GC as well as provides some tuning advice.
This presentation was given to the system adminstration team to give them an idea of how GC works and what to look for when there is abottleneck and troubles.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
2. Agenda.
Java Heap Management
Simple Garbage Collection Statistics
• Generating the Data
• Isolating the Data
• Graphing the Data
• Interpreting the Data
• Improving Performance
Advanced Garbage Collection Statistics
• Generate, Isolate, Graph, Interpret, Improve
Java Command Line Arguments Recap
3. Java Heap.
Young Generation
• Eden
- Where new objects are created
• Survivor spaces
- Where garbage collector places objects that are still in use
Old Generation
• Where tenured objects are placed
References
• http://java.sun.com/docs/hotspot/gc/ (1.3.1)
• http://java.sun.com/docs/hotspot/gc1.4.2/
4. Minor Garbage Collection.
Occurs when no room in eden for new object
Marks all reachable objects in eden and “from” survivor space
Copies those objects to “to” survivor space
• Updates references accordingly
• If “to” survivor space fills, overflows to old generation
Resets allocation pointer to start of eden
H A B C D E
I E F G H G I
Old Generation Eden From From
To To
Spaces
5. Major Garbage Collection.
Occurs when insufficient room in old generation to hold to-be-
tenured objects during a minor collection
• Pessimistic – need sufficient space to hold all object in young generation
• Pre-calculated – Minor collection reachable object algorithm run to
determine exactly now many objects will be tenured
Mark and Compact
• Reachable objects are marked
• Marked objects are moved to one end of the old generation
J K M M N O
L O V W A B C D
P Q R
X S T U X E F G H I
Old Generation Eden To From
Spaces
6. Agenda.
Java Heap Management
Simple Garbage Collection Statistics
• Generating the Data
• Isolating the Data
• Graphing the Data
• Interpreting the Data
• Improving Performance
Advanced Garbage Collection Statistics
• Generate, Isolate, Graph, Interpret, Improve
Java Command Line Arguments Recap
7. Generating Simple GC Data.
-verbose:gc command line option
java ... –verbose:gc ... my.java.app ...
Results:
...
[GC 1860K->1388K(1984K), 0.0005059 secs]
Minor
[GC 1900K->1446K(1984K), 0.0006679 secs]
collections [GC 1958K->1468K(2112K), 0.0006251 secs]
[Full GC 1468K-> 195K(2112K), 0.0131045 secs]
Major and ...
Time it took
minor
collection Total heap size
Heap in use after collection
Heap in use before collection
9. Interpreting the Regular Expression.
The ’’ char is an escape character, both in Java and in
regular expressions.
[(?:Full |)GC (d*)K->(d*)K(d*K), ([d.]*) secs]
[(?:Full |)GC - match literal ‘[Full GC ’ or ‘[GC ’
(d*)K-> - capture all digits before the literal text ‘K->’
(d*)K - capture all digits before the literal text ‘K’
(d*K) - discard the digits and literal text ‘K’ within parenthesis
- capture all digits and decimal point after the
, ([d.]*) secs]
comma and space, and before the literal text ‘secs]’
[Full GC 1468K-> 195K(2112K), 0.0131045 secs]
10. Graphing the Simple GC Data.
Load the CSV file into a spreadsheet
Sum the third column - total time spent
on GC
Create fourth column
• Third column * 10000 (or 100000)
• Gets times within range of columns 1 and 2
Create a graph containing columns
1, 2 and 4.
11. Graphing in Excel.
Select first column only
Create an “XY (Scatter)” graph
Wizard step 2, click Series tab
and add columns 2 and 4 to
the series.
• Click Add
• Name: Type or select row 1 cell
• X Values: leave empty
• Y Values: Select cells in column
Suggest creating new sheet
for the chart
12. Graphing in StarOffice.
Swap the 3rd and 4th columns (seconds*10000 is now the
3rd column)
Select the first 3 columns
and create chart
• Put chart in new sheet
• Select ‘lines’ chart type
• Select ‘normal’ variant
After chart is created
• Turn off labels on the X axis
• Change width of data series
lines to 0.02” or higher.
13. Interpreting Graphed GC Data.
Typical GC data graph
For many GCs, the heap slowly
fills as objects get moved to the
old generation
• Blue (or magenta) lines with
positive slope
Then a full GC happens
• Drop in blue (or magenta) lines
• Yellow dot in higher position
14. Interpreting Graphed GC Data.
Three Phases Phase 1 Phase 2 Phase 3
Phase 1
• Working set equilibrium
• Ideal graph
• No full GC
Phase 2
• Full GC with heap not full
- High GC times (yellow
dots above blue zig-zag)
• App called System.GC()
Phase 3
• Incremental working set
equilibrium
• Implies various sub-phases
each of which adds to
working set
15. Improving Performance, Before.
Goal: 1000 business transactions in 12 minutes
Heap set to: -Xms1024m –Xmx1024m
18 minute run, 472 seconds (7.8 minutes) in garbage collection
Each GC is
freeing very
little memory
16. Improving Performance, After.
-Xms1024m –Xmx1024m -XX:NewSize=300m –XX:MaxNewSize=300m
12 minute run, 25 seconds in garbage collection
• 70 collections instead of 8000 (no major/full collections)
• Average collection freed 240MB instead of just 1MB
17. Agenda.
Java Heap Management
Simple Garbage Collection Statistics
• Generating the Data
• Isolating the Data
• Graphing the Data
• Interpreting the Data
• Improving Performance
Advanced Garbage Collection Statistics
• Generate, Isolate, Graph, Interpret, Improve
Java Command Line Arguments Recap
18. More GC Data.
PrintGCDetails command line option
java ... –XX:+PrintGCDetails ... my.java.app ...
Results:
Minor [GC [DefNew: 17131K->1606K(18432K), 0.0082055 secs]
collection 44904K->29379K(63488K), 0.0083625 secs]
[GC [DefNew: 17990K->17990K(18432K), 0.0000839 secs]
[Tenured: 27772K->3759K(45056K), 0.0454394 secs]
Major and 45763K->3759K(63488K), 0.0459597 secs]
minor
collection Time it took
Heap size
Sizes are for young Heap in use after collection
generation, old
generation, and total heap Heap in use before collection
19. And Even More GC Data.
PrintHeapAtGC command line option
• java ... –XX:+PrintHeapAtGC ... my.java.app ...
Results:
{Heap before GC invocations=422:
Heap
def new generation total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, 0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423:
Heap
def new generation total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, 0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
}
20. PrintHeapAtGC Data.
{Heap before GC invocations=422:
Heap
def new generation total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, 0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423:
Heap
def new generation total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, Data from before GC
0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
}
21. PrintHeapAtGC Data.
{Heap before GC invocations=422:
Heap
def new generation total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, Data from after GC
0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423:
Heap
def new generation total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, 0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
}
22. PrintHeapAtGC Data.
{Heap before GC invocations=422:
Heap
def new generation total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, 0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
Memory
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
addresses:
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
Memory
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
-addresses
start
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423:
- next
Heap
- end
def new generation
eden space 16384K,
total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, 0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
}
23. PrintHeapAtGC Data.
{Heap before GC invocations=422:
Heap
def new generation total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, 0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
Before GC, eden ‘next’
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
pointer is at end
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423:
Heap
def new generation total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, 0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
After GC, eden ‘next’
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
}
pointer is at start
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
24. PrintHeapAtGC Data.
{Heap before GC invocations=422:
Heap
def new generation For each generation
total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, 0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423: Memory in use
Heap
def new generation total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, 0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
Memory allocated
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
}
25. PrintHeapAtGC Data.
{Heap before GC invocations=422:
Heap For each generational sub-space
def new generation total 18432K, used 17639K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 100% used [0x6eb40000, 0x6fb40000, 0x6fb40000)
from space 2048K, 61% used [0x6fd40000, 0x6fe79df8, 0x6ff40000)
to space 2048K, 0% used [0x6fb40000, 0x6fb40000, 0x6fd40000)
tenured generation total 45056K, used 6403K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70580f78, 0x70581000, 0x72b40000)
Percentage of that
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
Heap after GC invocations=423: memory that is in use
Heap
def new generation total 18432K, used 1197K [0x6eb40000, 0x6ff40000, 0x6ff40000)
eden space 16384K, 0% used [0x6eb40000, 0x6eb40000, 0x6fb40000)
from space 2048K, 58% used [0x6fb40000, 0x6fc6b4e8, 0x6fd40000)
to space 2048K, 0% used [0x6fd40000, 0x6fd40000, 0x6ff40000)
tenured generation Amount of memory allocated
total 45056K, used 6416K [0x6ff40000, 0x72b40000, 0x72b40000)
the space 45056K, 14% used [0x6ff40000, 0x70584190, 0x70584200, 0x72b40000)
compacting perm gen total 8192K, used 1597K [0x72b40000, 0x73340000, 0x76b40000)
the space 8192K, 19% used [0x72b40000, 0x72ccf598, 0x72ccf600, 0x73340000)
}
26. Isolating the Data.
Extract data
• Need a very complex regular expression
• CSV file, spreadsheet, with many columns
Interesting data
• Memory in use by each generation
- Before and after each collection
• Percent in use of “from space” New data
- NOTE: “After” data same as next “Before” data worth
graphing
27. Graphing and Analyzing the Data.
“From Space” usage is between 10%
and 60%
Adjust from space size using
SurvivorRatio option
• -XX:SurvivorRatio=ratio
• Eden-size = survivor-size * ratio
• Eden-size + 2 * survivor-ratio = young-gen-
size
Example:
• -XX:NewSize=200M –XX:SurvivorRatio=8
• Eden: 160MB, each Survivor Space: 20MB
Aim for 90-95% usage after collection
• Typically, with large young generations, use
larger ratio (e.g. 32)
28. Agenda.
Java Heap Management
Simple Garbage Collection Statistics
• Generating the Data
• Isolating the Data
• Graphing the Data
• Interpreting the Data
• Improving Performance
Advanced Garbage Collection Statistics
• Generate, Isolate, Graph, Interpret, Improve
Java Command Line Arguments Recap
29. Garbage Collection Info Options.
-verbose:gc
• Heap usage before and after GC
• Time spent during GC
-XX:+ PrintGCDetails
• Generation and heap size before and after GC
• Time spent during GC
-XX:+ PrintHeapAtGC
• Generation sizes before and after GC
• Space sizes and percent in use before and after GC
• Memory locations of the heap, its generations, and their spaces
30. Java Tuning Options.
-Xmssizem, -Xmxsizem
• Minimum and maximum heap size
• Set both sizes to the same value
-XX:NewSize=sizem, -XX:MaxNewSize=sizem
• Minimum and maximum young generation size
• Set both sizes to the same value
• Set to about 1/3 or 1/4 the size of the heap.
-XX:SurvivorRatio=ratio
• Number of times the eden space is larger than the “from” space
• Try for maximum of 90-95% usage
31. Conclusions.
The HotSpot™ JVM provides a variety of options
for gathering garbage collection statistics.
Those statistics are easily extracted using
• A simple Java application using
• A regular expression
The extracted data is easily graphed using a
spreadsheet application.
Examining the resulting graph
• Tells a lot about what the application is doing
• Enables selection of proper heap sizing to improve
performance of the application.