efficient online partial evaluationsumii/pub/gpc.pdfefficient online partial evaluation eijiro sumii...

Efficient Online Partial EvaluationEijiro Sumii

Naoki KobayashiUniversity of Tokyo

({sumii,koba}@yl.is.s.u-tokyo.ac.jp)

Partial Evaluation

source program p(s,d)+

static input s´

Partial Evaluation


static input s´

Reduce/residualize static/dynamicportions of p(s´,d)

↓

Partial Evaluation


static input s´


↓specialized program ps´(d)

Partial Evaluation


static input s´


↓specialized program ps´(d) s.t.

p(s´,d) = ps´(d) for any dynamic input d(Hopefully, the r.h.s. is faster)

Online PE and Offline PE

When to decide "static or dynamic"?


When to decide "static or dynamic"?– During specialization, with static input

⇒ Online PE


When to decide "static or dynamic"?– During specialization, with static input

⇒ Online PE– Before specialization, without static

input⇒ Offline PE

Merits and Demerits of Online PE and Offline PE

• Online PE is– more precise, but...


• Online PE is– more precise, but– less efficient

• Takes 10-100 times as much PE time




• Offline PE is– more efficient, but...




• Offline PE is– more efficient, but– less precise

• Requires more binding-time improvment

Our Goal and Approach

Combine– the precision of online PE, and– the efficiency of offline PE

by– going back to a naive online partial

evaluator, and– optimizing it without losing its precision

• State-based let-insertion• Cogen approach to online PE• Type-based use analysis

Overview

• Introduction• Related work• A naive online partial evaluator• Our optimizations

– State-based let-insertion– Cogen approach to online PE– Type-based use analysis

• Experiments• Conclusion

Related Work (I)

To reduce interpretive overheads• Self-application in online PE

[Ruf-93, Sperber-96, etc.]⇒ Cogen approach is simpler and faster

Related Work (I)

To reduce interpretive overheads• Self-application in online PE

[Ruf-93, Sperber-96, etc.]⇒ Cogen approach is simpler and faster

• Cogen approach to offline PE[Thiemann-96, etc.]⇒ We adopted it into online PE

Related Work (II)

To reduce unnecessary computations• (Monovariant) BTA's

– for offline PE [Henglein-91, Asai-99, etc.]– for online PE [Ruf-93, Sperber-96]

Related Work (II)

To reduce unnecessary computations• (Monovariant) BTA's

– for offline PE [Henglein-91, Asai-99, etc.]– for online PE [Ruf-93, Sperber-96]

• Abstract occurrence counting analysis [Bondorf-90]

⇒ Our analysis subsumes all of these in a single framework

Overview




A Naive Online Partial Evaluator

E (expression) ::= x | λx.E | E@E


E (expression) ::= x | λx.E | E@Eonpe : exp → env → value option × exp

(symbolic value)



(symbolic value)onpe(x)ρ = ρ(x)



(symbolic value)onpe(x)ρ = ρ(x)onpe(λx.E)ρ = ⟨Some(λv.onpe(E)ρ[x:=v]),

…⟩




λx◊.#2(onpe(E)ρ[x:=⟨None, x◊⟩])⟩




λx◊.#2(onpe(E)ρ[x:=⟨None, x◊⟩])⟩onpe(E1@E2)ρ = let a = onpe(E2)ρ in …




λx◊.#2(onpe(E)ρ[x:=⟨None, x◊⟩])⟩onpe(E1@E2)ρ = let a = onpe(E2)ρ in

case onpe(E1)ρ of …





case onpe(E1)ρ of ⟨Some(v), _⟩ ⇒ v a | …





case onpe(E1)ρ of ⟨Some(v), _⟩ ⇒ v a| ⟨None, e⟩ ⇒ ⟨None, e@#2(a)⟩

Examples

• λx.(λy.y)x → λx.x

Examples

• λx.(λy.y)x → λx.x#2(onpe(λx.(λy.y)@x)[ ])

Examples


→ #2⟨…, λx◊.#2(onpe((λy.y)@x)[x:=⟨None, x◊⟩])⟩

Examples


→ #2⟨…, λx◊.#2(onpe((λy.y)@x)[x:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(let a = onpe(x)[x:=⟨None, x◊⟩] in …)⟩

Examples


→ #2⟨…, λx◊.#2(onpe((λy.y)@x)[x:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(let a = onpe(x)[x:=⟨None, x◊⟩] in …)⟩→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in …)⟩

Examples


→ #2⟨…, λx◊.#2(onpe((λy.y)@x)[x:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(let a = onpe(x)[x:=⟨None, x◊⟩] in …)⟩→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in …)⟩→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in

case onpe(λy.y)[…]of …)⟩

Examples


→ #2⟨…, λx◊.#2(onpe((λy.y)@x)[x:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(let a = onpe(x)[x:=⟨None, x◊⟩] in …)⟩→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in …)⟩→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in

case onpe(λy.y)[…]of …)⟩

→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ incase ⟨Some(λv.onpe(y)[…, y:=v]), …⟩of …)⟩

Examples


→ …→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in

case ⟨Some(λv.onpe(y)[…, y:=v]), …⟩of ⟨Some(v), _⟩ ⇒ v a| …)⟩

Examples


→ …→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in


→ #2⟨…, λx◊.#2((λv.onpe(y)[…, y:=v]) ⟨None, x◊⟩)⟩

Examples


→ …→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in


→ #2⟨…, λx◊.#2((λv.onpe(y)[…, y:=v]) ⟨None, x◊⟩)⟩→ #2⟨…, λx◊.#2(onpe(y)[…, y:=⟨None, x◊⟩])⟩

Examples


→ …→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in


→ #2⟨…, λx◊.#2((λv.onpe(y)[…, y:=v]) ⟨None, x◊⟩)⟩→ #2⟨…, λx◊.#2(onpe(y)[…, y:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(⟨None, x◊⟩)⟩

Examples


→ …→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in


→ #2⟨…, λx◊.#2((λv.onpe(y)[…, y:=v]) ⟨None, x◊⟩)⟩→ #2⟨…, λx◊.#2(onpe(y)[…, y:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(⟨None, x◊⟩)⟩→ #2⟨…, λx◊.x◊⟩

Examples


→ …→ #2⟨…, λx◊.#2(let a = ⟨None, x◊⟩ in


→ #2⟨…, λx◊.#2((λv.onpe(y)[…, y:=v]) ⟨None, x◊⟩)⟩→ #2⟨…, λx◊.#2(onpe(y)[…, y:=⟨None, x◊⟩])⟩→ #2⟨…, λx◊.#2(⟨None, x◊⟩)⟩→ #2⟨…, λx◊.x◊⟩→ λx◊.x◊

Examples

• λx.(λy.y)x → λx.x– Reduces expressions inside functions

Examples


• let f = λx.1 in ⟨f 2, f⟩ → ⟨1, λx.1⟩– Uses both the static value and the

dynamic expression of fcf. "both" BTA [Asai-99]

Examples


• let f = λx.1 in ⟨f 2, f⟩ → ⟨1, λx.1⟩– Uses both the static value and the

dynamic expression of fcf. "both" BTA [Asai-99]

• λx.1+(if true then 2 else x) → λx.3– Doesn't require context duplication

• cf. continuation-based PE [Lawall-Danvy-94]

Let-Insertion is Necessary

• to avoid code duplicationlet f = λx.1+2 in ⟨f, f⟩

→ let f = λx.3 in ⟨f, f⟩rather than ⟨λx.3, λx.3⟩

Let-Insertion is Necessary

• to avoid code duplication• to preserve semantics under side-

effectsλf.1+(let x = f 2 in 3)

→ λf.let x = f 2 in 4rather than λf.4

Continuation-Based Let-Insertion [Lawall-Danvy-94]

Insert let-bindings by manipulating delimited continuations

• Creates a let-insertion point by delimiting a context

delimit-let(e) ≡ reset(e)

Continuation-Based Let-Insertion [Lawall-Danvy-94]

Insert let-bindings by manipulating delimited continuations

• Creates a let-insertion point by delimiting a context

delimit-let(e) ≡ reset(e)• Inserts a let-binding by extracting

the delimited contextadd-let(e) ≡ shift(λk. let x◊ = e in k x◊)

Continuation-Based Let-Insertion in Offline PE

λf.(1+(let x = f@2 in 3))


λf.(1+(let x = f@2 in 3))⇒ λf.delimit-let(1+(let x = add-let(f@2) in 3))


λf.(1+(let x = f@2 in 3))⇒ λf.delimit-let(1+(let x = add-let(f@2) in 3))→ λf.reset(1+(let x =

shift(λk. let x◊ = (f@2) in k x◊) in 3))



shift(λk. let x◊ = (f@2) in k x◊) in 3))→ λf.let x◊ = (f@2) in (k x◊)

where k[ ] = 1+(let x = [ ] in 3)




where k[ ] = 1+(let x = [ ] in 3)→ λf.let x◊ = (f@2) in (1+(let x = x◊ in 3))




where k[ ] = 1+(let x = [ ] in 3)→ λf.let x◊ = (f@2) in (1+(let x = x◊ in 3))→ λf.let x◊ = (f@2) in 4

Continuation-Based Let-Insertion in Online PE

onpe(x)ρ = ρ(x)onpe(λx.E)ρ = ⟨Some(λv.onpe(E)ρ[x:=v]),

add-let(λx◊.delimit-let(#2(onpe(E)ρ[x:=⟨None, x◊⟩])))⟩

onpe(E1@E2)ρ = let a = onpe(E2)ρ incase onpe(E1)ρ of ⟨Some(v), _⟩ ⇒ v a

| ⟨None, e⟩ ⇒ ⟨None, add-let(e@#2(a))⟩

Problems of the Naive Online Partial Evaluator

Correct but inefficient, because of• shift/reset for let-insertion


Correct but inefficient, because of• shift/reset for let-insertion• interpretive overheads

– environment manipulation– syntax dispatch– universal domain (in typed languages)




• unnecessary computations– unnecessary let-insertions– unnecessary Some/None tags– unused values/expressions

Overview




State-Based Let-Insertion

context := λe.e


context := λe.eadd-let(e) ≡

(context := !context o λx.let z◊ = e in x; z◊)



(context := !context o λx.let z◊ = e in x; z◊)delimit-let(e) ≡

let tmp = !context in …




let tmp = !context in(context := λe.e; …




let tmp = !context in(context := λe.e;let body = e in …




let tmp = !context in(context := λe.e;let body = e inlet head = !context in …




let tmp = !context in(context := λe.e;let body = e inlet head = !context in(context := tmp; …




let tmp = !context in(context := λe.e;let body = e inlet head = !context in(context := tmp;head body))

Overview




Interpretive Approach


static input s´

Partially-evaluate p(s´,d)with an interpreter


Cogen Approach

source program p(s,d)

Cogen Approach

source program p(s,d)↓

generating extension cogenp(s)

Cogen Approach


generating extension cogenp(s)+

static input s´

Cogen Approach



static input s´

Execute cogenp(s´) directlywithout an interpreter

↓

Cogen Approach



static input s´

Execute cogenp(s´) directlywithout an interpreter


Offline-PE Combinators[Thiemann-96]

From an interpretive partial evaluator, derive a cogen


From an interpretive partial evaluator, derive a cogen using

• Higher-order abstract syntax [Pfenning-Elliott-88]– Substitute object-level bindings with

meta-level bindings


From an interpretive partial evaluator, derive a cogen using

• Higher-order abstract syntax [Pfenning-Elliott-88]– Substitute object-level bindings with

meta-level bindings• Deforestation

– Compose the syntax constructors with the partial evaluator

Online-PE Combinators

Define abs and app s.t.onpe(λx.E)ρ ≈ abs(λx.E′) under ρ′onpe(E1@E2)ρ ≈ app(E1′, E2′) under ρ′



e.g.,onpe(λx.(λy.y)@x)[ ]≈ abs(λx.app(abs(λy.y),x))= ⟨…, λx◊.x◊⟩



e.g.,onpe(λx.(λy.y)@x)[ ]≈ abs(λx.app(abs(λy.y),x))= ⟨…, λx◊.x◊⟩

abs(f) = ⟨Some(λv.f v), λx◊.#2(f ⟨None, x◊⟩]))⟩app(p, a) = case p of ⟨Some(v), _⟩ ⇒ v a

| ⟨None, e⟩ ⇒ ⟨None, e@#2(a)⟩

Overview




Unnecessary Computations in Online PE

• Unused valuese.g., in λx.1+2 → λx.3,

abs(λx.…)= ⟨Some(λx.…), λx◊.…⟩

can be simplified to⟨( ), λx◊.…⟩


• Unused values• Unnecessary tags & unused expressions

e.g., in (λx.x)a → a,app(abs(λx.x),a)= case abs(λx.x)

of ⟨Some(v), _⟩ ⇒ v a | ⟨None, …⟩ ⇒ …= case ⟨Some(λx.x), λx◊.…⟩

of ⟨Some(v), _⟩ ⇒ v a | ⟨None, …⟩ ⇒ …can be simplified to

case ⟨λx.x, ( )⟩ of ⟨v, _⟩ ⇒ v a= let v = λx.x in v a


• Unused values• Unnecessary tags & unused expressions• Unnecessary let-insertions

An expression requires no let-insertion– if it has no side-effects, and– if it appears at most once

in the specialized program

Type-Based Use Analysis

Count the uses of values/expressionsρ (raw type) ::= α | τ → τ | τ × ττ (annotated type) ::= ρ(s,d)


Count the uses of values/expressionsρ (raw type) ::= α | τ → τ | τ × ττ (type) ::= ρ(s,d)

s (static use) ::= 0 (never) | ω (always) |T (sometimes)– Whether a static value is available or not


Count the uses of values/expressionsρ (raw type) ::= α | τ → τ | τ × ττ (type) ::= ρ(s,d)

s (static use) ::= 0 (never) | ω (always) |T (sometimes)– Whether a static value is available or not

d (dynamic use) ::= 0 (never) |1 (at most once) | ω (any number of times)– How many times a dynamic expression

appears in the specialized program

Examples

• let f = λx.x in f 3

Examples

• let f : int →(ω,0) int = λx.x in f 3⇒ 3

Examples


• let f = λx.x in f

Examples


• let f : int →(0,1) int = λx.x in f⇒ λx.x

Examples



• let f = λx.x in ⟨f 3, f⟩

Examples



• let f : int →(ω,1) int = λx.x in ⟨f 3, f⟩⇒ ⟨3, λx.x⟩

Examples




• let f = λx.x in ⟨f 3, f, f⟩

Examples




• let f : int →(ω,ω) int = λx.x in ⟨f 3, f, f⟩⇒ let f = λx.x in ⟨3, f, f⟩

More Examples

• let f = λx.x inlet g = λy.f ing

More Examples

• let f : α →(0,1) α = λx.x inlet g : β →(0,1) α →(0,1) α = λy.f ing⇒ λy.λx.x

More Examples


• let f = λx.x inlet g = λy.f in⟨g 1, g 2⟩

More Examples


• let f : α →(0,ω) α = λx.x inlet g : β →(ω,0) α →(0,1) α = λy.f in⟨g 1, g 2⟩⇒ let f = λx.x in ⟨f, f⟩

Typing Rule

Example: λ-abstractionΓ ? (s,d) · Γ0

d ≠ 0 ⇒ s1 ≠ ωΓ0, x : ρ1

(s1,d1)├ e : τ2

Γ├ λx.e : ρ1

(s1,d1) →(s,d) τ2

Type Inference

• Construct the type derivation– assigning variables for uses, and– generating constraints for the variables

Type Inference

• Construct the type derivation– assigning variables for uses, and– generating constraints for the variables

• Solve the constraints– beginning with the most conservative

approximation (s = T and d = ω for all sand d), and

– refining it with iterations (linear w.r.t. the number of use variables)

Overview




Conditions

• Mobile Pentium II 400MHz• 128MB Main Memory• Debian/Linux 2.2.10• SML/NJ 110.0.3

Applications

• impAn interpreter for a simple imperative

language• match1

A pattern matcher with the pattern static• match2

The same pattern matcher with the string static

• power

Effects of Optimizations:Time for Partial Evaluators

00.10.20.30.40.50.60.70.80.9

1

imp match1 match2 power

naive(=1)+state+cogen+analysis

Comparison of BTA's:Time for Generating Extensions

00.10.20.30.40.50.60.70.80.9

1


Henglein's BTAafter BTI byhandSperber's BTA(=1)

our type-baseduse analysis

Comparison of BTA's:Time for Specialized Programs

00.10.20.30.40.50.60.70.80.9

1


no PE (=1)

Henglein's BTAafter BTI byhandSperber's BTA

our type-baseduse analysis

Conclusion

• We presented "hybrid" PE that combines– the precision of online PE, and– the efficiency of offline PE

Conclusion


• Our future work includes– correctness proof– termination guarantee

Conclusion


• Our future work includes– correctness proof– termination guarantee

• The paper to appear in PEPM'00 is available from http://www.yl.is.s.u-tokyo.ac.jp/~sumii/pub/

efficient online partial evaluationsumii/pub/gpc.pdfefficient online partial evaluation eijiro sumii...

Documents