Terracotta for Distributed Caches

Distribute popular OSS caches, your own cache, or a Java collection

Distributed caches powered by Terracotta can see as much as 100x throughput vs. native solutions, with no changes to existing code.

This is only possible because of Terracotta's unique JVM clustering approach, which can support any cache data structure, from java.util.HashMap, to EHCache, OSCache, or JBoss Cache.

Whether you are writing a new application, or need to scale out an existing application, and need to use a cache, Terracotta's DSO is simple and fast.

Simple

Ease of Integration – Supports all common caching APIs

• All Java Datastructures, not just Maps. HashMap, ConcurrentHashMap, ArrayList, Vector, TreeMap etc.
• All common caching frameworks including EHCache, JBoss Cache, JCS, & OSCache
• No Java.io.Serializable - Terracotta doesn't use or require objects to implement Java.io.Serializable
• Automatic - Terracotta is a runtime service. There are not 6 different ways to configure it, it just works.

Get started with Terracotta Integrations for Distributed Caches

(click to enlarge)

Large Caches – Terracotta automatically moves data to be local or remote depending on your use

• Virtual Heaps mean Terracotta Caches can be as large as you need. 100GB. 200GB. 1TB.
• Lazy Loading allows your JVM to stay 32 bit and exhibit good GC characteristics

Consistent – all cache operations are made cluster-wide

• Transactional updates ensure no race conditions
• No JTA, custom locking, etc.

Dynamic – automatically windows data

• Regularly flushes unneeded cache from your JVM
• Dynamically pages in objects, fields, or entire object graphs to your JVM as needed
• JVMs do not get bothered with cache updates for entries not currently in heap

POJO loading – freedom to load the cache the way you need

• Get notified when cache nodes join and leave the cluster
• Load data streams in series or parallel
• Load directly into multiple java.util.collections with no redundant object storage
• Write-aside / write-behind thru java.util.Queue
• Write-thru / read-thru with your caching framework's existing APIs

Fast

Fine-grained – push only what changes, only where needed

• Work with the cache as one large pool of data
• Individual JVMs will automatically fault in and flush out data as needed for local workloads
• Partial java.util.collections that ensure that an entire object graph is not needed

Batched

• Fault in cache entries that tend to get accessed together, automatically
• Push cache updates in batch simply by defining synchronized blocks around many cache operations

Tunable – Tune your cache on one server; the same semantics apply when distributed

• Cache expiration via common evictor schemes including TTL, LRU, LFU
• Cluster-wide LRU / LFU without moving objects around the network

Reliable

Highly Available – Terracotta Architecture delivers 100% cache uptime

• Zero cache loss when individual or all JVMs go down
• Unlimited network-based cache backups for resiliancy

Safe Data – data will not get corrupted when distributed

• Cluster-wide consistency avoids complex race conditions

Avoid Cache Flushes – Eliminate cache flushes in production

• Built-in object versioning. Apps can be upgraded in production without flushing cache
  
  (click to enlarge)