Scaling Up Java™ Applications On Windows® Servers

Juarez Junior

Systems Architect – Unisys Global Outsourcing

Presentation Scope.We will focus on

• Systems using 8 or more 32-bit Intel CPUs

• Systems running

- Microsoft Windows 2000

- Microsoft Windows Server 2003

• HotSpot™-based Java virtual machines

- Sun JVM 1.4.x

- Unisys JVM 1.4.1

• Command line options

Goal: Identify what you can do toboost the performance of Javaapplications without rewriting.

Agenda.Java and Scalability

Cache Invalidation

Process and Thread Affinity

Java Heap and Heap Sizing

Conclusions

Agenda.Java and Scalability

Cache Invalidation

Process and Thread Affinity

Java Heap and Heap Sizing

Conclusions

Definition of Scalability.The ability to reliably increase performance by increasing numbers of resources

• Scale outIncrease the number of systems available to process the workload, all systems operating semi-independently.

• Scale upIncrease the number of CPUs and other system resources to process the workload, all in one system (single OS instance).

02468

101214

1 6 11 16 21 26 31

CPUs

Scale

Facto

r

Untuned

Tuned

Scaling Up Java.

Agenda.Java and Scalability

Cache Invalidation

Process and Thread Affinity

Java Heap and Heap Sizing

Conclusions

Cache Invalidation.Consider two threads in same application accessing same data

• Data is loaded into cache on each processor

• One thread updates data

- Data in other cache becomes invalid

Now consider many threads running on many processors

• One update can invalidate data in 31 caches

Similar story with a shared cache

• External cache shared among 4 processors

False sharing

• Threads have independent data that resides in adjacent memory

• Caches are loaded based on cache line size (16-128 bytes)

Memory

CPUCPU

Cache

CPUCPU

Cache

Data

Data DataData

Data

X

Agenda.Java and Scalability

Cache Invalidation

Process and Thread Affinity

Java Heap and Heap Sizing

Conclusions

OS

Process and Thread Affinity.Contain process/threads to run on certain processors

• Keep threads within processor group if external cache

Process affinity

• Useful if threads share many common objects

- J2EE-based application servers

Thread affinity

• Useful if threads are independent

• Useful in scale-up scenario

App2App1

CPU

CPU

CPU

CPU

App3

CPU

CPU

CPU

CPU

Thread Affinity.

05

101520253035

1 6 11 16 21 26 31

CPUs

Sca

le F

acto

r

NoThreadAffinityThreadAffinity

Process Affinity.

Dem

o

Process Affinity For Application Servers.Assign 2 – 4 CPUs per application server instance

• Cluster the instances

• Load balance among them

Issue:FACT: Affinity is set by process name or id

FACT: Process id is assigned at runtime

FACT: Process name for every instance is java.exe

PROBLEM: How do you assign affinity for each instance?

SOLUTION: Make copies of java.exe (e.g. java01.exe)

- assign affinity for each copy

- modify batch files to use copies

Agenda.Java and Scalability

Cache Invalidation

Process and Thread Affinity

Java Heap and Heap Sizing

Conclusions

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/

Young Generation Sizing.Goal: 1000 business transactions in 12 minutes

Heap set to: -Xms1024m –Xmx1024m

18 minute run, 472 seconds (7.8 minutes) in garbage collection

Young Generation Sizing.-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

Survivor Ratio.-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

Use –XX:PrintHeapAtGC to monitor• Heap after GC invocations=11:new generation total 18432K, used 1604Keden space 16384K, 0% usedfrom space 2048K, 78% usedto space 2048K, 0% used

Aim for 90-95% usage after collection

• Typically, with large young generations, use larger ratio (e.g. 32)

CPU

CPU

CPU

CPU

Thread-Local Allocation Blocks.Each thread gets its own piece of Eden

-XX:UseTLAB

-XX:TLABSize=sizek

• Common sizes: 64, 128, 256

• tlab-size * #-threads < eden-size

Use parallel collection

• -XX:+UseParallelGC

Align TLABs to cache line size

Eden

Thread 1

Thread 2

Thread 3

Thread 4

Agenda.Java and Scalability

Cache Invalidation

Process and Thread Affinity

Java Heap and Heap Sizing

Conclusions

Pop QuizState 5 things you can do to improve the performance of a Java application

• Set process affinity

• Use thread affinity, if appropriate

• Set the young generation size (1/3 to 1/4 size of heap)

--XX:NewSize=sizem –XX:MaxNewSize=sizem

- Try heap of 800MB, young generation of 200MB

• Set the survivor ratio

--XX:SurvivorRatio=ratio

• Use thread-local allocation blocks

--XX:+UseTLAB –XX:TLABSize=sizek

Questions?