eddies: continuously adaptive query processing ross rosemark

Eddies: Continuously Eddies: Continuously Adaptive Query ProcessingAdaptive Query Processing

Ross RosemarkRoss Rosemark

Goals of PresentationGoals of Presentation

What are traditional query optimizers?What are traditional query optimizers? What are the problems with these What are the problems with these

optimizers?optimizers?

What is an eddy?What is an eddy? How does an eddy work?How does an eddy work? Discuss how an eddy self tunes query Discuss how an eddy self tunes query

plans?plans?

Traditional Query OptimizerTraditional Query Optimizer

Metadata (statistics) about the distribution Metadata (statistics) about the distribution of data is collected by the query optimizerof data is collected by the query optimizer

Based on the metadata the query Based on the metadata the query optimizer determines the most energy optimizer determines the most energy efficient query planefficient query plan

Query plan is executed.Query plan is executed.

This is good for snapshot queries (short This is good for snapshot queries (short lived queries)lived queries)

ProblemsProblems The problem with this approach is that data became streamingThe problem with this approach is that data became streaming

InternetInternet Sensor nodesSensor nodes Etc.Etc.

The query plan chosen by the query optimizer could eventually become The query plan chosen by the query optimizer could eventually become inefficient if the metadata statistics changeinefficient if the metadata statistics change Cost of operatorsCost of operators Operator selectivies could changeOperator selectivies could change Rate tuples arrive from inputsRate tuples arrive from inputs

Also it’s difficult to just re-optimize a queryAlso it’s difficult to just re-optimize a query Determining when to re-optimize the query is a difficult research issue that has Determining when to re-optimize the query is a difficult research issue that has

not been addressed.not been addressed. Must determine not only when you should re-optimize but that re-optimizing still leaves Must determine not only when you should re-optimize but that re-optimizing still leaves

produces the same stateproduces the same state

Example Example

Assume a query that asks for Employees Assume a query that asks for Employees age and salary > 100000 is issued into the age and salary > 100000 is issued into the sensor network.sensor network. Initially the predicate salary > 100000 will be Initially the predicate salary > 100000 will be

very selective… hence eliminating a lot of very selective… hence eliminating a lot of tuplestuples As older employees in the database start to be As older employees in the database start to be

read the predicate salary > 100000 will be less read the predicate salary > 100000 will be less selectiveselective

Lets show some things Eddie must Lets show some things Eddie must consider.consider.

Eddie should:Eddie should: Increase synchronizationIncrease synchronization Increase the moments of SymmetryIncrease the moments of Symmetry

Synchronization BarriersSynchronization Barriers Synchronization barriersSynchronization barriers

Where one operation hinders the speed of another operationsWhere one operation hinders the speed of another operations

Extreme exampleExtreme example Assume you have a merge join on two duplicate-free inputs. (slowlo and Assume you have a merge join on two duplicate-free inputs. (slowlo and

fasthi)fasthi) Assume that during processing the next tuple is always consumed from the Assume that during processing the next tuple is always consumed from the

relation that had the lowest valuesrelation that had the lowest values Assume that slowlo is a slowly delivered external relation with many low Assume that slowlo is a slowly delivered external relation with many low

columns in it’s bandwithcolumns in it’s bandwith Assume that fasthi is high bandwith (i.e. delivers tuples fast) and has only Assume that fasthi is high bandwith (i.e. delivers tuples fast) and has only

high values in it’s columnhigh values in it’s column In this example fasthi is delayed why slowlo delivers tuplesIn this example fasthi is delayed why slowlo delivers tuples

Known as a synchronization barrierKnown as a synchronization barrier

Desirable to minimize the number of Synchronization barriersDesirable to minimize the number of Synchronization barriers

Moments of SymmetryMoments of Symmetry You can only re-optimize at a moment You can only re-optimize at a moment

of symmetryof symmetry A moment of symmetry is when the A moment of symmetry is when the

query is executed to a point that the query is executed to a point that the optimizer can change the query plan optimizer can change the query plan without affecting the way the query without affecting the way the query plans predicates are performedplans predicates are performed

Typically happens in joinsTypically happens in joins

ExampleExample Assume you have a nested loop join Assume you have a nested loop join

with inner relation R and outer relation with inner relation R and outer relation S.S.

In this example you can only re-optimize In this example you can only re-optimize this join when R is completely scanned.this join when R is completely scanned.

It is possible to re-optimize in the middle It is possible to re-optimize in the middle of scanning S but the join algorithm of scanning S but the join algorithm would then have to be changedwould then have to be changed

EddyEddy An Eddy was designed to dynamically re-An Eddy was designed to dynamically re-

optimize queries.optimize queries. The authors implemented Eddies in a RiverThe authors implemented Eddies in a River

A river is a shared nothing parallel query A river is a shared nothing parallel query processing framework that dynamically processing framework that dynamically adapts to fluctuations and workloadsadapts to fluctuations and workloads

An eddy is implemented via a module in a river containing an arbitrary number of input relations, a number of participating unary and binary modules, and a single output relation

An Eddy also maintains a fixed size buffer An Eddy also maintains a fixed size buffer of tuples that need to be processed of tuples that need to be processed

Each operator takes two tuples, processes Each operator takes two tuples, processes them and delivers them back to the eddythem and delivers them back to the eddy

Eddy (Cont)Eddy (Cont)

A tuple in a eddy is associated with a tuple descriptorA tuple in a eddy is associated with a tuple descriptor Contains a vector of Ready bits and Done bitsContains a vector of Ready bits and Done bits

The Eddy ships the tuple to only the operators that have The Eddy ships the tuple to only the operators that have the Ready bits turned onthe Ready bits turned on

After an operators is processed it’s Done bits are setAfter an operators is processed it’s Done bits are set If all done bits are set the tuple is sent to the Eddy’s outputIf all done bits are set the tuple is sent to the Eddy’s output Else it’s sent to another operatorsElse it’s sent to another operators

Eddy (Cont)Eddy (Cont)

So how do you route tuples to the different So how do you route tuples to the different Eddy operatorsEddy operators In this paper they look at multiple different In this paper they look at multiple different

waysways

Naïve SchemeNaïve Scheme Eddies buffer is implemented as a priority queueEddies buffer is implemented as a priority queue

Recall the buffer is used to store tuples that should be processed by the Recall the buffer is used to store tuples that should be processed by the EddiesEddies

When a tuple enters a buffer it’s priority is set to lowWhen a tuple enters a buffer it’s priority is set to low After it’s processed by an operator in the Eddy and returned to the After it’s processed by an operator in the Eddy and returned to the

buffer it’s priority is set to highbuffer it’s priority is set to high

This ensures that tuples do not get stuck in the Eddy.This ensures that tuples do not get stuck in the Eddy.I.e. starvationI.e. starvation

This scheme dynamically adjusts to work required of operatorsThis scheme dynamically adjusts to work required of operators Operators that are slower (i.e. take 4 seconds vs. 1 second will receive Operators that are slower (i.e. take 4 seconds vs. 1 second will receive

less tuples)less tuples) Note each operator has a fixed size queueNote each operator has a fixed size queue

Once queue is filled up no more tuples can be inserted into queueOnce queue is filled up no more tuples can be inserted into queue

Lottery SchemeLottery Scheme Each time a tuple is routed to a operator the operator is credited Each time a tuple is routed to a operator the operator is credited

with a ticketwith a ticket When the operator returns a tuple the eddy one ticket is debited When the operator returns a tuple the eddy one ticket is debited

from the eddies running count for that operatorfrom the eddies running count for that operator Tracks how efficiently a operator drains tuples from the systemTracks how efficiently a operator drains tuples from the system

When a tuple is to be routed to an operator the Eddy holds a lotteryWhen a tuple is to be routed to an operator the Eddy holds a lottery Only the operators that have their Ready bit sets can participate in the Only the operators that have their Ready bit sets can participate in the

lotterylottery An operator’s chance of “winning the lottery” and receiving

the tuple corresponds to the count of tickets for that operator.

Dynamically adjusts to selectivity of operators

Window SchemeWindow Scheme Problem with lottery scheme is that it uses to much past infoProblem with lottery scheme is that it uses to much past info

Problem: An operator that gained a lot of ticket initially but then became Problem: An operator that gained a lot of ticket initially but then became slow slow

In this scheme the lottery scheme is modified such that the lottery In this scheme the lottery scheme is modified such that the lottery only looks at tickets gained by an operator in a fixed window.only looks at tickets gained by an operator in a fixed window. Keeps track of two types of ticketsKeeps track of two types of tickets

Banked ticketsBanked tickets Used when running the lotteryUsed when running the lottery

Escrow ticketsEscrow tickets Used to measure efficiency during the windowUsed to measure efficiency during the window

At the end of a window At the end of a window Banked Tickets = Escrow TicketsBanked Tickets = Escrow Tickets Escrow Tickets = 0Escrow Tickets = 0

Ensure operators re-approve themselves each windowEnsure operators re-approve themselves each window

ComparisonComparison

Shows that due to Shows that due to “Fluid Dynamics” (i.e. “Fluid Dynamics” (i.e. the varying rates of the varying rates of operators) the Naïve operators) the Naïve approach naturally approach naturally adjusts based on the adjusts based on the cost of operatorscost of operators

Shows that Lottery Shows that Lottery also adjusts based on also adjusts based on workloadworkload

ComparisonComparison Naïve eddies does not adjust based on selectivityNaïve eddies does not adjust based on selectivity

Naïve performs between the best and worseNaïve performs between the best and worse Lottery does adjust based on selectivityLottery does adjust based on selectivity

JoinsJoins

Shows that Lottery Shows that Lottery performs nearly performs nearly optimallyoptimally

Naïve performs Naïve performs between the best and between the best and worstworst

Joins (Cont)Joins (Cont)

All joins are ripple All joins are ripple joinsjoins Change selectivity of Change selectivity of

join predicatejoin predicate

In all cases the Eddy In all cases the Eddy with the Lottery is with the Lottery is close to optimalclose to optimal

Window SchemeWindow Scheme

Both cases are Both cases are related to different related to different query plansquery plans Shows eddy is in Shows eddy is in

between the best and between the best and worst caseworst case

AdaptabilityAdaptability

Toggle the cost of the Toggle the cost of the operator 3 times operator 3 times throughout throughout experimentexperiment Notice that Eddy Notice that Eddy

switches how many switches how many tuples are first tuples are first processed by that processed by that operatoroperator

ProblemsProblems Does not work well when Does not work well when

there is initially a long there is initially a long delay at an operatordelay at an operator

Eddy gives all tuples to Eddy gives all tuples to operator because operator because operator is not returning operator is not returning tuples that satisfy the join tuples that satisfy the join predicates criteriapredicates criteria Not until after the delayNot until after the delay

Notice eventually this Notice eventually this problem is figured out by problem is figured out by EddyEddy Just make take some timeJust make take some time