book

The Definitive Guide to Terracotta: Cluster the JVM™ for Spring, Hibernate, and POJO Scalability

Name: The Definitive Guide to Terracotta: Cluster the JVM™ for Spring, Hibernate, and POJO Scalability
Author: Terracotta Inc.
ISBN: 9781590599860

by Terracotta Inc.

June 2008

Intermediate to advanced

364 pages

9h 25m

English

Apress

Read now

Unlock full access

Copyright
About Terracotta, Inc.
About the Authors
About the Technical Reviewer
Introduction
How This Book Is StructuredPrerequisitesContacting the Authors
1. Theory and Foundation Forming a Common Understanding
1.1. Definition of the Terracotta Framework1.1.1. Network Attached Storage Similarities to Terracotta1.1.1.1. A Layer of Abstraction1.1.1.2. Adding Networked File Storage1.1.1.3. Parallels to Terracotta1.1.2. Transparency of Memory Location1.1.3. Putting Transparency and Clustering Together1.2. Honoring the Java Memory Model1.3. Being a Service Has Advantages1.3.1. Availability1.3.2. Scalability1.3.3. Avoiding Bottlenecks1.4. Use Cases1.4.1. Distributed Caching1.4.2. Database Offload1.4.3. Session Replication1.4.4. Workload Partitioning1.5. Summary
2. History of Terracotta
2.1. Approaches to Scaling2.1.1. Scale the Database2.1.2. In-Memory Replication2.1.3. All Paths Lead to Partitioning2.2. Terracotta's Origin in a Web Monster2.2.1. The Application Is a Giant Computer2.3. Terracotta Makes L2 General Purpose2.3.1. Original L2 Was Intrusive2.3.2. We Needed More Transparency2.3.3. Transparency Equals General Purpose2.3.4. Transparent Scalability with Availability2.3.5. Transparent Clustering Service Revisited2.3.6. Transparency Delivers Higher Scalability2.4. Clustered Application Servers and Clustered Caches2.5. Summary
3. Jumping Into Terracotta
3.1. Hello Clustered World3.1.1. Clustering HelloClusteredWorld3.1.2. Why HelloClusteredWorld Works3.1.3. Alternatives to Terracotta3.2. A Tour Through Terracotta3.2.1. Downloading and Installing Terracotta3.2.2. Terracotta Installation Layout3.2.3. Terracotta Scripts3.2.4. Step-by-Step Hello Clustered World in Unix3.2.4.1. Creating a Project Skeleton3.2.4.2. Creating HelloClusteredWorld.java3.2.4.3. Creating the Terracotta Configuration3.2.4.4. Making the Terracotta Server Run in Persistent Mode3.2.4.5. Configuring the Terracotta Client3.2.4.6. Configuring Roots3.2.4.7. Configuring Instrumentation3.2.4.8. Configuring Locks3.2.4.9. Reviewing the Configuration3.2.4.10. Starting the Terracotta Server3.2.4.11. Starting Two Clustered Instances of HelloClusteredWorld3.2.4.12. Viewing Runtime Data in the Terracotta Administration Console3.2.4.13. High Availability3.2.4.14. Heap Durability3.2.5. Step-by-Step Hello Clustered World in Eclipse3.3. Implications for Every Developer3.4. Summary
4. POJO Clustering
4.1. All About Objects and Roots4.2. Clustered Objects4.3. Virtual Heap and Memory Management4.4. Distributed Garbage Collection4.5. Managing Object Changes and Coordinating Threads4.6. Locks4.6.1. Autolocks and Named Locks4.6.2. Lock Level4.6.3. Distributed wait() and notify()4.7. Transactions4.8. Distributed Method Invocation4.9. Transparency and Bytecode Instrumentation4.10. Portability4.11. Boot JAR Classes4.12. Physically vs. Logically Managed Objects4.13. Nonportable and Logically Managed Classes4.14. Portability Contexts4.14.1. Field Change4.14.2. Logical Action4.14.3. Object Graph Traversal4.15. Transient Fields and On-Load Behavior4.15.1. Initializing Transient Fields on Load4.16. Clustered POJOs Step by Step4.16.1. What Do We Mean by POJO?4.16.2. What's a Clustered POJO?4.16.3. Why Clustered POJOs?4.17. An Example of Clustered POJOs4.17.1. The Example Classes4.17.1.1. The ProductImpl Class4.17.1.2. The Catalog Class4.17.1.3. The ShoppingCartImpl Class4.17.1.4. The ActiveShoppingCarts Class4.17.1.5. The Roots Class4.17.1.6. The Main Class4.17.2. Clustering Requirements for the Example4.17.3. Configuration for the Example4.17.4. Running the Example4.17.5. What Just Happened4.17.6. What the Example Shows4.18. Summary
5. Caching
5.1. The Pain of Caching5.1.1. The Pain of Large Data Sets5.1.2. The Pain of Staleness5.1.3. The Pain of Duplication5.2. How Terracotta Can Help5.3. A Simple Example of Caching5.4. Distributed Caching5.5. Transparent Distributed Caching5.6. Caching with Maps5.6.1. Unsorted Maps5.6.2. Sorted Maps5.6.3. Autolocked Collections5.6.3.1. Downloading and Installing the Autolocked Collections TIM5.6.3.2. Using Autolocked Collections5.6.4. Bulk Loading a Map5.6.5. Locking and Maps5.6.6. Maps of Maps5.7. A Deeper Look at Caching5.7.1. Eviction and Expiration5.7.2. Persistence5.7.3. Distributed Caching5.7.4. Partitioned Data5.7.5. Leveraging Terracotta5.8. Caching with Ehcache5.8.1. Rewriting the Cache Example5.8.2. Using Ehcache with Terracotta5.8.2.1. Enhancements and Configuration5.8.2.2. Downloading and Installing Ehcache Integration5.8.2.3. Using Ehcache with Terracotta5.9. Summary

6. Hibernate with Terracotta Using Terracotta to Offload the Database
6.1. Object-Relational Mapping6.2. How Does Hibernate Work?6.3. Typical Hibernate Invocation6.4. Using Terracotta to Improve Hibernate6.5. How Terracotta Improves Hibernate Performance6.5.1. Basic Steps for Improving Performance of a Hibernate Application6.5.2. Baseline Performance6.5.3. Add Hibernate to Save Three DB Calls6.5.4. Enable the Second-Level Cache to Save Five SQL Calls6.5.5. Clustering the Session Objects6.5.6. Benchmarking the Enhancements6.6. Configuring Hibernate to Work with Terracotta6.6.1. Configuring a Second-Level Cache6.6.1.1. Configuring Ehcache6.6.1.2. Enabling Ehcache Second-Level Caching in Hibernate6.6.1.3. Configuring Terracotta6.6.2. Configuring Terracotta for Use with Detached Instances6.6.2.1. Refactoring Your Application6.6.2.2. Configuring Terracotta to Use the Hibernate Integration Module6.6.2.3. Storing the Detached Instances6.6.2.3.1. Store the Detached Instances in the HTTP Session Context6.6.2.3.2. Store the Detached Objects in a HashMap6.6.2.3.3. Store the Detached Objects in a Clustered Cache6.6.2.4. Reattaching the Detached Instances6.6.2.5. Suggestions for Further Reading6.7. Debugging, Testing, and Tuning Concerns6.7.1. Verifying Ehcache Configuration Clustering6.7.2. Tuning the Second-Level Cache6.7.3. Tuning Detached Instances6.8. Summary
7. Extending HTTP Sessions with Terracotta
7.1. What Are HTTP Sessions?7.1.1. Server-Side State Management7.1.2. Automatic Time-Out of Stale Data7.1.3. Manual Invalidation to Clear Out Data7.1.4. Events to Coordinate State Modification7.1.5. Session State Persistence7.2. Distributed HTTP Sessions7.2.1. Motivation for Using HTTP Sessions7.2.1.1. Accessing Sessions State from Other Nodes7.2.1.2. Dynamic Horizontal Scale-Out to Handle Traffic Spikes7.2.1.3. High Availability in Case of Server Failure7.2.2. Alternatives to HTTP Sessions7.2.2.1. Distributed Caches7.2.2.2. A Database As a Central Store7.3. Distributed HTTP Sessions with Terracotta7.3.1. How Terracotta Sessions Work7.3.1.1. Transparently Plugs into Web Containers7.3.1.2. Appropriate Lock Granularity and Isolation7.3.2. Benefits7.3.2.1. No Serialization7.3.2.2. Rolling Upgrades7.3.2.3. Fine-Grained Changes7.3.2.4. Simultaneous Linear Scalability and High Availability7.3.2.5. No Need to Set Attributes After Each Change7.3.2.6. Easy to Set Up7.4. Using Terracotta and HTTP Sessions7.4.1. Shared Session State7.4.1.1. Package and Configure the Web Application7.4.1.2. Install and Run the Application with the Terracotta Sessions Configurator7.4.1.3. Trying the Example7.4.2. HTTP Sessions with Structured Session Attributes7.4.2.1. Packaging and Configuring the Web Application7.4.2.2. Manually Configuring and Installing the Example into Tomcat7.4.2.3. Verifying Fine-Grain Change Detection7.5. Understanding HTTP Sessions with Terracotta7.5.1. Supported Platforms7.5.2. Architecture Considerations7.5.2.1. The Effects of a Round-Robin Load Balancer7.5.2.2. Using a Sticky Load Balancer7.5.2.3. Running a Terracotta Cluster7.6. Summary
8. Clustering Spring
8.1. A Sample: Spring Beans Without a Database8.2. Running the Example on a Single JVM8.3. Running the Example Clustered with Terracotta8.4. A Note on DI and Terracotta8.5. Growing Spring Beans8.6. Clustering Spring Beans8.7. Running with Clustered Spring Beans8.8. Terracotta Session Clustering for Spring8.9. Summary
9. Integration Modules
9.1. Clustering by Configuration9.2. Using TIMs9.2.1. Clustering a Synchronized Map9.2.2. Importing a TIM9.2.3. Module Repositories9.2.4. The Terracotta Forge9.3. Creating a TIM9.3.1. TIM Anatomy9.3.1.1. Creating a Manifest9.3.1.2. Terracotta Configuration9.3.2. Creating a Simple TIM9.3.3. Creating TIMs with Maven9.3.3.1. Module Versioning9.3.4. Including Code in a TIM9.3.4.1. Defining a Bundle Activator9.3.4.2. Configuration with Code9.3.4.3. Class Replacement and Modification9.3.4.4. Using Maven to Create TIMs with Code9.4. Summary
10. Thread Coordination
10.1. Terracotta and Thread Coordination10.2. Clustering Threads10.2.1. Thread Coordination Using Concurrency Primitives10.2.2. Thread Coordination Using the java.util.concurrent Package10.2.3. Thread Coordination and JMX Cluster Events10.2.4. Thread Coordination with Queues10.3. Summary
11. Grid Computing Using Terracotta
11.1. What Are Grids?11.1.1. Compute Grids vs. Data Grids11.1.2. How Grids Handle Scalability11.1.3. How Grids Handle Failover and High Availability11.1.4. Use Cases11.2. Introducing the Master/Worker Pattern11.3. Master/Worker in Java11.3.1. Using the Java Language's Thread Coordination Primitives11.3.2. Using the java.util.concurrent Abstractions11.3.3. Using the CommonJ Work Manager Specification11.4. Getting Started: Naïve Single Work Queue Implementation11.4.1. Implementing a Single-JVM Naïve Master/Worker Container11.4.1.1. What About My Work?11.4.2. Clustering Our Master/Worker with Terracotta11.5. Handling Real-World Challenges11.6. Refactoring for Large Workloads, Routing, and Work Failover11.6.1. Minimizing Contention and Maximizing Locality of Reference11.6.2. Routing Strategies11.6.3. Dealing with Work Failure and Recovery11.6.4. Refactoring the Worker11.6.5. Update the Terracotta Configuration11.6.6. Using the Master/Worker System11.6.7. Running the Master/Worker System11.7. Refactoring Work Batching, Worker Failover, and Dynamic Worker Management11.7.1. Work Batching11.7.2. Dynamic Worker Management11.7.3. Worker Failover11.7.4. How to Use and Run the Fault-Tolerant Master/Worker System11.8. Building a Distributed Web Spider11.9. When Not to Use the Master/Worker Pattern11.10. Summary
12. Visualizing Applications
12.1. Observing an Application12.2. Visualization Tools and Architecture12.3. The Sample Inventory Application12.3.1. Modifying to Generate Load12.3.1.1. Copying the Sample12.3.1.2. Pounder Methods12.3.1.3. Tuning the Locks12.3.1.4. Using Separate Roots12.3.1.5. Updating the CLI12.3.1.6. Updating the Terracotta Configuration12.3.1.7. Compile and Run the Application12.3.2. Taking Performance Snapshots12.4. Potential Bottlenecks12.4.1. Recalling the Motherboard12.4.2. Inside the Terracotta Server12.4.2.1. SEDA12.4.2.2. Terracotta's SEDA Pipeline12.4.3. Looking for Locality Issues12.4.4. Specific Bottlenecks in inventory.pounder12.4.4.1. Broadcasting Changes12.4.4.2. Lock Acquisition12.5. Visualizing the Bottlenecks12.6. Managing Production Environments12.7. Summary

Content preview from The Definitive Guide to Terracotta: Cluster the JVM™ for Spring, Hibernate, and POJO Scalability

Chapter 12. Visualizing Applications

Tuning applications that run in a cluster is hard. What makes tuning difficult is that the application is a logical entity running across processes and machines, while the available tools work almost exclusively at the process or machine level.

For example, you know from Chapter 5 that Terracotta helps distribute application cache data. We also know an application that accesses the cache in a random way will not scale, because the objects have to move around the cluster through the Terracotta server. But none of the tools that exist for performance tuning (including CPU and memory monitoring tools, JVM heap monitoring tools, and Java application profilers) would show that a distributed cache is slow, because ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Spring: Developing Java Applications for the Enterprise

Publisher Resources

ISBN: 9781590599860Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Definitive Guide to Terracotta: Cluster the JVM™ for Spring, Hibernate, and POJO Scalability

by Terracotta Inc.

Chapter 12. Visualizing Applications

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.