CSE 662 Fall 2019

Same great algorithms,
awesome new hardware flavor

Adapting Software to Hardware

Hardware adaptation uses standard transformations:

Batching: Prefetch blocks of data to avoid random seeks.
Partitioning: Group related blocks of data to minimize cross-partition work.
Reordering: Cluster data accesses for better cache locality.

The hard part is picking where to apply the transformations and selecting values for the transformation's parameters

Typesystems

A collection of rules that assign a property called a type to the parts of a computer program: variables, expressions, etc...
[Wikipedia]

Type	Meaning
$D$	Primitive Type (int, float, etc...)
$[\tau]$	An array of elements with type $\tau$
$<\tau_1,\tau_2>$	A pair of elements of types $\tau_1$ and $\tau_2$ .
$\tau_1\rightarrow\tau_2$	A function with one argument of type $\tau_1$ and one return value of type $\tau_2$ .

Monad Algebra

A primitive language for describing data processing.

Operator	Meaning
$\lambda x.e$	Define a function with body $e$ that uses variable $x$ .
$e_1\;e_2$	Apply the function defined by $e_1$ to the value obtained from $e_2$ .
$\textbf{if}\;c\;\textbf{then}\;e_1\;\textbf{else}\;e_2$	If $c$ is true then evaluate $e_1$ , and otherwise evaluate $e_2$ .

Operator	Meaning
$< e_1, e_2 >$	Construct a tuple from $e_1$ and $e_2$ .
$e.i$	Extract attribute $i$ from the tuple $e$ .
$[e]$	Construct a single-element array from e.
$[]$	Construct an empty array.
$e_1 \sqcup e_2$	Concatenate the arrays $e_1$ and $e_2$ .

$\textbf{flatMap}(f : \tau_1 \rightarrow [\tau_2])(e : [\tau_1])$

Apply function $f$ to every element of array $e$ . Concatenate all of the arrays returned by $f$ .

$\textbf{foldL}(c : \tau_2, f : < \tau_2, \tau_1 >)(e : [\tau_1])$

Apply function $f$ to every element of array $e$ , with each invocation passing its return value to the next call (e.g., aggregation)

$\textbf{for}(xB : [\tau_1] [k] \leftarrow e_{in} : [\tau_1])(e_{loop} : [\tau_2])$

Extract blocks of size $k$ from $e_{in}$ . For each block compute a flatMap using expression $e_{loop}$ .

Example: Block-Nested-Loop Join

# Loop over blocks in outer rel.

$\textbf{for}( xB [k_1] \leftarrow R )$

# Loop over blocks in inner rel.

$\textbf{for}( yB [k_2] \leftarrow S )$

# Loop over elems in outer block.

$\textbf{for}( x \leftarrow xB )$

# Loop over elems in inner block.

$\textbf{for}( y \leftarrow yB )$

# Join test.

$\textbf{if}\;joinCond(x, y)$

# Add pair if success.

$\textbf{then}\;[< x, y >]$

# Add nothing if not.

$\textbf{else}\;[]$

Expression	Context	Result Size
$\textbf{for}( xB [k_1] \leftarrow R )$	$\Gamma_1 = R \mapsto [1]^x, S \mapsto [1]^y$	$[ < 1, 1 > ]^{\frac{x}{k_1} \cdot \frac{y}{k_2} \cdot k_1 \cdot k_2}$
$\textbf{for}( yB [k_2] \leftarrow S )$	$\Gamma_2 = \Gamma_1 \cup xB \mapsto [1]^{k_1}$	$[ < 1, 1 > ]^{\frac{y}{k_2} \cdot k_1 \cdot k_2}$
$\textbf{for}( x \leftarrow xB )$	$\Gamma_3 = \Gamma_2 \cup yB \mapsto [1]^{k_2}$	$[ < 1, 1 > ]^{k_1 \cdot k_2}$
$\textbf{for}( y \leftarrow yB )$	$\Gamma_4 = \Gamma_3 \cup x \mapsto 1$	$[ < 1, 1 > ]^{k_2}$
$\textbf{if}\;joinCond(x, y)$	$\Gamma_5 = \Gamma_4 \cup y \mapsto 1$	$[ < 1, 1 > ]^1$
$\textbf{then}\;[< x, y >]$	$\Gamma_5$	$[ < 1, 1 > ]^1$
$\textbf{else}\;[]$	$\Gamma_5$	$0$

IO Model

IO Costs have 2 components:

$InitCom$ : The cost of initializing a connection (e.g., seek time).

$UnitTr$ : The cost of transferring one unit of data.

Costs are defined for every pair of memory hierarchy levels:

$UnitTr(HDD \rightarrow RAM)$ is the cost of reading from HDD into Ram.

$InitCom(RAM \rightarrow HDD)$ is the cost of seeking to a write from Ram onto a HDD.

Expression	Result Size	HDD to RAM	RAM to HDD
$\textbf{for}( xB [k_1] \leftarrow R )$	$[ < 1, 1 > ]^{\frac{x}{k_1} \cdot \frac{y}{k_2} \cdot k_1 \cdot k_2}$	$x+\frac{x}{k_1}y$	$2xy$
$\textbf{for}( yB [k_2] \leftarrow S )$	$[ < 1, 1 > ]^{\frac{y}{k_2} \cdot k_1 \cdot k_2}$	$y$	$2k_1y$
$\textbf{for}( x \leftarrow xB )$	$[ < 1, 1 > ]^{k_1 \cdot k_2}$	$0$	$2k_1k_2$
$\textbf{for}( y \leftarrow yB )$	$[ < 1, 1 > ]^{k_2}$	$0$	$(1+1)k_2$
$\textbf{if}\;joinCond(x, y)$	$[ < 1, 1 > ]^1$	$0$	$(1+1)k_2$
$\textbf{then}\;[< x, y >]$	$[ < 1, 1 > ]^1$	$0$	$(1+1)k_2$
$\textbf{else}\;[]$	$0$	$0$	$0$

HDD: $R, S, Result$ RAM: $x, xB, y, yB$

Rewrite Rules

Batching

$for(x [1] \leftarrow R)\; e \Rightarrow for(xB [k] \leftarrow R)\; for(x [1] \leftarrow xB)\; e$

Reordering Iterators

$for(x_1 [k_1] \leftarrow R_1)\;for(x_2 [k_2] \leftarrow R_2) \Rightarrow$

$for(x_2 [k_2] \leftarrow R_2)\;for(x_1 [k_1] \leftarrow R_1)$

Size-Dependent, Commutative Functions

$f \Rightarrow (\lambda< x_1, x_2>.f(\textbf{if}\;|x_1|\leq |x_2|\;\textbf{then}< x_1, x_2 >\;\textbf{else}\;< x_2, x_1 >))$

$f \Rightarrow (\lambda< x_1, x_2>.f(\textbf{if}\;|x_1|\leq |x_2|\;\textbf{then}< x_2, x_1 >\;\textbf{else}\;< x_1, x_2 >))$

Legorithmics

Adapting Software to Hardware

Adapting Software to Hardware

Adapting Software to Hardware

Typesystems

Typesystems

Typesystems

Types

Type Examples

Inference Rules

Inference Examples

Monad Algebra

Monad Algebra

Example - Average

Cost Estimation

Cardinality Estimation

Cardinality Estimation

Cardinality Estimation

For Loops

If Then Else

Example: Block-Nested-Loop Join

IO Model

Rewrite Rules

Batching

Reordering Iterators

Size-Dependent, Commutative Functions

The Optimizer

Legorithmics