Data Grids with Oracle Coherence

But data replication does General solution is toThe Data Bottleneck not scale... scale repository by– grid performance is replicating data acrosscoupled to how several machines.quickly it can send … but dataand receive data partitioning does. Coherence has evolved functions for Low latency access is server side facilitated by simplifying processing too. the contract.These include tools forproviding reliable,asynchronous, Coherence leverages these todistributed work that can provide the fastest, mostbe collocated with data. scalable cache on the market. 2

DS Node DS NodeClient Data Source DS Node DS Node 3

DS Node DS Node DS Node Bottleneck DS NodeClient Data Source DS Node DS Node DS Node DS Node 4

DB DB •  Data exists on a shared file system. •  Multiple machines add Data on bandwidth and processingDB Disk DB ability DB DB 6

Greatly increases bandwidth available for reading data. Copy 1 Copy 2 Data onCopy 6 Disk Copy 3 Copy 5 Copy 6 7

Copy 1 Copy 2 Data is copied to different machines.Copy 6 Copy 3 What is wrong with Copy 5 Copy 6 this architecture? 8

Becomes out of date Client Writes Data Record 1 = fooRecord 1 = bar Data on Disk Record 1 = foo 9

Client Writes Data Record 1 = foo Lock Record 1Record 1 = bar Data on Disk Record 1 = foo 10

Copy 1 Copy 2ClientWrites Controller Copy 6 Copy 3 Data Copy 5 Copy 4 All nodes must be locked before data can be written => The Distributed Locking Problem 11

Each machine is responsible for asubset of the records. Each record exists on only one machine. 1, 2, 3… 97, 98, 99… Client 765, 769… 169, 170… 333, 334… 244, 245… 12

• Data volume will naturally increase with the number of machines in the cluster as the data only exists in one place.• Writes are only ever sent to one machine (that holds the singleton piece of data being modified) so write latency scales with the cluster. 13

• Oracle RAC• Gigaspaces• Terracotta• Oracle Coherence 14

Node NodeNode Node Node Node 15

The Post-It Note is a great example of Business Evolution – a productthat starts its life in one role, but evolves into something else …otherwise known as Accidental Genius.Coherence is another good example!! 17

Node NodeClient Client Near Node Node Database Client Cache Node Node 18

All data is stored as key value pairs [key1, value1] [key2, value2] [key3, value3] [key4, value4] [key5, value5] [key6, value6] 21

•  DB used for persistence only - Coherence is typically prepopulated•  Caching is over two levels (server and client) Bulk load at start up Node Node Node Node Database Node Node Write Asynchronous 22

Coherence does not support:-  ACID-  Joins (natively)-  SQL*Coherence works to a simplercontract. It is efficient only forsimple data access. As such it cando this one job quickly andscalably. 23

What is RAC? RAC is a clustered database which runs in parallel over several machines. It supports all the features of vanilla Oracle DB but has better scalability, fault tolerance and bandwidth. Clustered therefore fault tolerant and scalable Cache Cache DB DB Node Node Supports ACID,Cache Cache SQL etc Node DB DBNode Cache Cache Node Node No disk access DB DB 24

Fast Fault Tolerant Scalable 25

In-memory storage of data – no disk induced latencies (unless you want them). Objects held in serialised form Node NodeClient Async write behind Client Near Node Node Client Database Cache Node Node Queries run in parallel Near Cache kept Coherent via where possible Proactive update/expiry of data as (aggregations etc) it changes 26

InMemory Cache(Fragile) DB 27

Data is held on at least two machines. Thus, should one fail,the backup copy will still be available. Node 1 Node 2 Node 6 Node 3 Node 5 Node 4 Node 2 Backup The more machines, the faster failover will be! 28

-  Scale the application by adding commodity hardware-  Coherence automatically detects new cluster members- Near-linear scalability due to partitioned data Processing / Storage / Node Node Node Bandwidth Node Node Node Node Node Number of nodes (n) 29

Not that resilient:- Single machine failure will be tolerated.- Concurrent machine failure will cause data loss.Key Point: Resilience is sacrificed for speed 30

• Coherence works to a simpler contract. It is efficient only for simple data access. As such it can do this one job quickly and scalably.• Databases are constrained by the wealth of features they must implement. Most notably (from a latency perspective) ACID.• In the bank we are often happy to sacrifice ACID etc for speed and scalability. 31

Summary so far… 32

Client cache.get( foo )Node Node Node Node Foo Well Known UDPHashing Algorithm 36

myCache.put( Key , Value );! Client Connection Connection Proxy Proxyta Storage Data Storage Data Storage Data StorageProcess Process Process ProcessPrimary Primary Primary PrimaryBackup Backup Backup Backup 37

ConsensusDeath detection is votebased – there is no centralmanagement I think Node I think Node X has died X has died Node XData Storage Data Storage Data Storage Data Process Process Process Pr Primary Primary… Primary Bar Pri Node X Redistribution Redistribution Backup Primary Backup…Backup Foo Backup Bar Ba Node X Repartioning Repartioning 38

Data Invalidation Message: value for key1 is now invalidNear Cache(in-process) Node Node Near Cache Node Node Client A key1, val cache.get(key1) Node Node cache.put(key1, SomethingNew) Client B 39

1, 2, 3… 97, 98, 99… Lock(Key3) Process Client 765, 769… 169, 170… Unlock(Key3) 333, 334… 244, 245…12 Network Hops(6 internal to cluster, 6 external to cluster) 40

Analogous to: Stored Procedures Key is Locked 1, 2, 3… 97, 98… cache.invoke(EP)Client 765, 769… 169, 170… EntryProcessor Key is 333, 334… 244, 245… Unlocked Class Foo extends AbstractProcessor ! public Object process(Entry entry)! public Map processAll(Set setEntries)! Your code goes here 41

cache.invoke("Key3",!new ValueChangingEntryProcessor( NewVal"));! 1, 2, 3… 97, 98, 99… cache.invoke(..) Client 765, 769… 169, 170… 333, 334… 244, 245…4 Network Hops(2 internal to cluster, 2 external to cluster) 42

Analogous to: Grid Taskservice.execute(new GCAgent(), null, null);! Node Node service.execute(some code) Client Node Node Node Node Run any arbitrary piece of code on any or all of the nodes 43

Analogous to: TriggersBacking Map Listeners / Triggers allow code to be run in response to a cache event such as an entry being added, updated or deleted. Key is Your code Locked goes here 1, 2, 3… 97, 98… cache.put(foo)Client 765, 769… 169, 170… MapListener 333, 334… MapListener ! Class 244, 245… Key is Public void entryInserted(MapEvent evt)! Unlocked public void entryUpdated(MapEvent evt)! public void entryDeleted(MapEvent evt)! 44

Analogous to: Triggers (but with fault tolerance and built in retry) Exception Retry Queue Thrown 1, 2, 3… 97, 98… cache.put(765, X)Client 765, 769… 169, 170… CacheStore Database Should multiple 333, 334… CacheStore ! Class 244, 245… changes be made to public void store(Object key, Object val)! the same key they will be coalesced public void erase(Object key)! 45

Called by Coherence Called by client Backing Map Entry Processor Locks the key Listener Takes Responds to a Parameters cache event &Returns Values CacheStore Invocable Is Guaranteed Coalesces changes 46

All cluster side programming must be done in Java. However clients can be:•  Java•  C#•  C++ Serialisation is done to an intermediary binary format known as POF. This allows theoretical transformation from POF directly to any language. Currently only Java, C# and C++ are supported. Node Node C# Object IPofSerialiser Node Node Java Object PofSerialiser Node Node 47

Java Invocable Run on Server Mapping via pof-config file Node Node C#MyInvocable Node Node Data objects are marshalled as Node Node described in previous slide 48

Set up associations between affinity attributes so that they are stored on the same machine Trades Market Data Affinity attributes define mappings between data 50

Trade and market data for the same ticker are collocated Trades Market Data Entry ProcessorPrice trade based onmarket data 51

Public class foo{! Public void bar(){! Send data to code !//do some stuff! DATA }! }!Public class foo{! Public void bar(){! Send code to data !//do some stuff! }! DATA}! 53

DS Node Node Node DS NodeClient Node Node DS Node Node Node DS Node Processing Layer: Data Layer: DataSynapse Grid Coherence Cluster 54

Node Node Client Node Node Node NodeProcesses are performed on the node where data exists 55

DS Node DBClient (Compute) (Data) CoherenceClient Data + Compute 56

Feed Cache Store Server Trade Cache Domain Processing EntryProcessor Update Trade 57

•  Free distribution of processing across multiple machines•  Free fault tolerance•  Free scalability to potentially thousands of machines A very enticing proposition for new applications 58

Coherence is not suitable for large scale processor intensive tasks (think Monte Carlo simulations etc). Why?•  Compute grids provide much more control of the execution environment (priorities, a UI etc)•  The grid is far more scalable in terms of compute power (dynamic provisioning of engines etc).•  The grid is much cheaper (per core) than Coherence. 59

Copy 1 Copy 2ClientWrites Controller Copy 6 Copy 3 Data Copy 5 Copy 4 61

1, 2, 3… 97, 98, 99…Client 765, 769… 169, 170… 333, 334… 244, 245… 62

InMemory Cache(Fragile) DB 64

Data affinity Reliable ProcessingTrades Market Data 1, 2, 3… 98… 97, Client 169, 170… Cache DB Store 333, 334… 245… 244, 65

So in conclusion… 66

http://www.benstopford.com	187
http://grumpy.junta.com.au	2
http://webcache.googleusercontent.com	2
http://toomanybits.wordpress.com	1

Data Grids with Oracle Coherence

by Ben Stopford on Apr 09, 2011

Accessibility

Upload Details

Usage Rights

4 Embeds 192

Statistics

Data Grids with Oracle Coherence — Presentation Transcript