Program specialization by supercompilation. (The supercompiler Scp4.) - PowerPoint PPT Presentation

Loading...

PPT – Program specialization by supercompilation. (The supercompiler Scp4.) PowerPoint presentation | free to download - id: 69f98-ZDc1Z



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Program specialization by supercompilation. (The supercompiler Scp4.)

Description:

gander. The gander says 'How do you do, one hundred geese?' The flock leader ... many again, and a half-many again, and a quarter of us, and also you, Gander, then ... – PowerPoint PPT presentation

Number of Views:81
Avg rating:3.0/5.0
Slides: 49
Provided by: andreipn
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Program specialization by supercompilation. (The supercompiler Scp4.)


1
Program specialization by supercompilation.
(The supercompiler Scp4.)
  • Andrei P. Nemytykh
  • Program System Institute, Russian Academy of
    Sciences,
  • Senior Researcher
  • http//www.botik.ru/PSI/RCMS/APP/nemytykh/nemytykh
    .html
  • http//www.botik.ru/pub/local/scp/refal5/nemytykh_
    cv.html

2
State of art of program transformation
  • During the last three decades the following most
  • promising program transformation methods
  • have been under development
  • generalized partial computation Yoshiko
    Futamura (Japan), 1971
  • supercompilation Valentin Turchin (Russia-USA),
    1972
  • partial evaluation Neil Jones (Denmark), 1983
  • deforestation Phillip Wadler (Great
    Britain-USA), 1985
  • and some others.

3
Reasons for program optimization
  • The methods can do almost nothing with programs
    that are already carefully optimized by a
    professional programmer in a lower-level
    language. The methods can clean a program of
    natural inefficiencies if the program has been
    developed inefficiently in a structured way,
    using various high-level techniques like
  • interpretation of specialized application-oriented
    languages and
  • component programming from libraries of general
    re-usable software, etc.
  • Thus, the methods are directed to
    provide degrees of freedom for new software
    technologies rather than to optimizing programs
    written in an old style.

4
Specialization the main idea
  • Let human be a program with two parameters
    knowledge and problem.
  • Then creating a specialist humanknowledge from
    human and knowledge is
  • a good example of specialization
  • humanknowledge(problem) human(knowledge,problem)
  • Specialist humanknowledge can solve problems
    much quicker than
  • an ordinary human when the problems are covered
    by his specific
  • knowledge.

5
A number of tasks for specialization.
ltF x0, ygt The first argument of a program F is
given, while the second is unknown. ltF ltG x, ygt
, z gt Let two programs F and G be given,
specialize a composition of applications of the
programs. That is specialization with respect to
a context of application. ltIntL ( Program )
e.data gt
ltGO gt An interpreter
IntL of a programming language L is specialized
with respect to a given program. IntL is written
in a language M, while the program is written
in L, so we expect an optimal program written in
M as a result of specialization. Thus a
specializer may be used as a compiler from L into
M, where M is the subject language of the
specializer.
6
What is supercompilation ?
  • Supercompilation is a technique of
    specialization of programs written in
  • a functional programming language. The
    technique was introduced in the
  • 1970s by V. F. Turchin. He proposed a task of
    creating tools to observe
  • operational semantics of a program, when a
    function F that is to be computed
  • by the program is fixed. As a result of such
    observations a new algorithmic
  • definition of an extension of the function F
    must be constructed. His ideas were
  • studied by a number of authors for a long time.
  • The main aim of a supercompiler is to perform as
    many actions of a given
  • parameterized application ( a task ) of a
    program uniformly on the parameters
  • as possible.
  • It is interesting that supercompilers can be
    used
  • as simple theorem provers
  • for simplification of definitions written in a
    programming language
  • as compilers
  • as transformers of genuine recursions into
    tail-recursions.

7
The Supercompiler SCP4
  • is an experimental specializer for a functional
    language Refal-5.
  • (There are no special restrictions on the
    input language.) Scp4 has been
  • implemented once again using Refal-5. Sources
    of the supercompiler,
  • executable modules and sources of Refal-5 are
    available for immediate
  • free download http//www.botik.ru/pub/local/s
    cp/refal5/
  • (by Andrei P. Nemytykh and Valentin F.
    Turchin).
  • Windows 98
  • Windows NT/2000/XP
  • Linux (Intel)
  • a user manual on the supercompiler and reports
    on several interesting
  • experiments with Scp4 by Alexandr V. Korlyukov
    (in Russian).
  • Alexandr P. Konyshev implemented a compiler from
    the intermediate
  • Scp4s language into the language C.

8
An introduction to REFAL (data)
  • REFAL (by V.F. Turchin) is a first-order
    strict functional language, where concatenation
    is associative and is used in infix notation.
    The language has another constructor for
    composing of tree structures. The semantics of
    the language is based on pattern matching. Unlike
    LISP the language is based on the model of
    computation known as Markov's algorithms. REFAL
    data are defined by the following grammar
  • d (d1) d1 d2 SYMBOL empty
  • empty / nothing /

Example
(A B) (C D)


-
A
B
C
D
9
The language REFAL (the first example definition)
Concatenation is associative. ENTRY Go e.xs
ltrepl B A (ltrepl A B (e.xs)gt)gt

-- A and B are
constants repl
--
pattern matching s.a s.b ( )
--
two types of variables s.a s.b (s.a e.xs) s.b
ltrepl s.a s.b (e.xs)gt -- s.-
can take symbols

-- e.- can take expressions

-- all functions are unary
The above given REFAL program is translation of
the following program Go(xs) repl(B,A,
repl(A,B,xs)) repl(a,b,xs) if Null(xs) then
else if Atom(car(xs))
then if a ? car(xs)
then b repl(a,b,cdr(xs))
10
An introduction to REFAL (associative
concatenation)
Example 1
Example 2 (Refal style reversing)
The palindrome predicate
Reversing a list of terms
Palindrome True   s.1 True   --
application constr. s.1 e.2 s.1 ltPalindrome
e.2gt  e.1 False
rev t.x e.ys ltrev e.ysgt t.x
-- empty expression
-- on the both sides.
/ Reversing a list of terms we may concatenate
a term taken by the variable t.x right on the end
of the list. The blank is used to denote the
concatenation. /
/ Pattern may be split from both sides a
symbol-variable s.1 is split from the left and
right sides. /
11
The language REFAL (data processing)
Concatenation is associative. ENTRY Go s.a
e.xs ltreplace s.a s.a (e.xs)gt replace
-- the empty expression is
argument of the ( ) constructor s.a s.b ( )
-- the empty expression on the right
side s.a s.b (s.a e.xs) s.b ltreplace s.a s.b
(e.xs)gt s.a s.b (s.x e.xs) s.x ltreplace s.a
s.b (e.xs)gt s.a s.b ((e.ys) e.xs) (ltreplace
s.a s.b (e.ys) gt) ltreplace s.a s.b (e.xs)gt
The above given REFAL program is translation of
the following program Go(xs) replace(a,a,
xs) replace(a,b, xs) if Null(xs) then
else if Atom(car(xs)) then if a ? car(xs)
then b replace(a,b,cdr(xs))
else car(xs)
replace(a,b,cdr(xs)) else
replace(a,b, car(xs)) replace(a,b,cdr(xs))
12
What is supercompilation ?
  • Supercompilation is a technique of
    specialization of programs written in
  • a functional programming language. The
    technique was introduced in the
  • 1970s by V. F. Turchin. He suggested a task of
    creating tools to observe
  • operational semantics of a program, when a
    function F that is to be computed
  • by the program is fixed. As a result of such
    observations a new algorithmic
  • definition of an extension of the function F
    must be constructed. His ideas were
  • studied by a number of authors for a long time.
  • The main aim of a supercompiler is to perform as
    many actions of a given
  • parameterized application ( a task ) of a
    program uniformly on the parameters
  • as possible.
  • It is interesting that supercompilers can be
    used
  • as simple theorem provers
  • for simplification of definitions written in a
    programming language
  • as a compiler

13
General structure of the Refal interpreter
task final inp.-prog.
Internal language
Entry config. Source prog.
Refal-5
result / undefined /
do Refal-step while( the task is not
solved ) / still is not completely evaluated
/ if( the task is determined ) result
task
Result
Refal-5
14
General structure of SCP4
Parameterized entry config.-s Source program
tasks final input program
Internal language
Refal-5
residual
/ empty / do current-task
head(tasks) driving folding
if( the current-task is solved )
global-analysis /
folded / specialization w.r.t the
global properties propagation of
the global inform. over the tasks
if( the current-task is not empty )
residual residual current-task
tasks tail(tasks)
while( tasks ) dead-code-analysis
C
Refal-5
parameterized entry points, residual program
15
Driving
The driving is an extension of the interpretation
of one Refal-graph (its input subset) step on
the parameterized sets of the input entries. The
purpose is to perform as many actions of the
Refal-graph machine uniformly on the parameter
values as possible.
Schoolboy driving
a ? x b 0
b ? 0
any x ?R
b 0
a ? 0
a ? x b 0
driving
b ?? 0
Ø
a ?? 0
x -b/a a ? 0
16
Folding
It folds the meta-tree of all possible
computations in a finite graph and is
launched immediately after the driving. I.e. the
folding tries to wrap the part of the path,
which is not folded to a given moment, from the
meta-tree root to a node, referred to as current
node, in the current driving cluster. The folding
is divided in two logically closed tools
reducing and generalization. Both tools use not
only syntactical but also semantic properties of
the function stack.
.
.
.
.
.
.
.
.
previous node
current node
17
Generalization (Obninsk condition (V.F. Turchin,
1989))
The definition reflects an assumed development of
the stack as follows Top Middlen Context
(condition for approximation of a
loop). Given two stacks labeled by the
times - Previous and Current, we say that this
pair indicates a loop if the stacks can be
represented in the form Previous
PreviousTop Context Current CurrentTop
Middle Context where the bottom of the stacks
is the length-most common part, i.e. this part
nowise took part in the process developing of the
function stack along the path from the previous
node to the current, and the "tops" of the two
stacks ( PreviousTop F1ptime_1, ,
FNptime_n CurrentTop F1ctime_1, ,
FNctime_n ) coincide modulo the creation times.
The Context determines computations immediately
after the loop.
Previous top
Context
Context
Current top
Middle
18
Obninsk condition (example)
Consider a definition of the unary
factorial. ENTRY IncFact e.n ltPlus (I) (ltFact
(e.n)gt)gt Fact ( ) I (e.n)
ltTimes (e.n) (ltFact (ltMinus (e.n) (I)gt)gt)gt
Times (e.u) ( ) (e.u)
(I e.v) ltPlus (ltTimes (e.u) (e.v)gt) (e.u)gt
Plus (e.u) ( ) e.u (e.u) (I
e.v) I ltPlus (e.u) (e.v)gt Minus (I e.u) (I
e.v) ltMinus (e.u) (e.v)gt (e.u)
( ) e.u "Lazy" development of the
stack along the main branch yields the following
sequence 1 IncFact1 2
Plus2 A
hypothesis is that the stack
3 Fact4 Plus3
will further have the form 4
Times5 Plus3 Fact
Timesn Plus3 5 Fact7
Times6 Plus3 The
stack formed on the fifth step is "similar" to
the stack created on the third step.
19
Homeomorphic embedding condition
  • Homeomorphic embedding condition specifies a
    "similarity" relation on the parts of the
    parameterized environments , which provides
    "positive" information of data. This relation is
    a variant of a relation originating by Higman and
    Kruskal and is a specification of the following
    term relation.
  • Let two terms Previous and Current be written on
    a blackboard by a chalk. We say the term Current
    is not less complex compared to the Previous iff
    the Previous can be obtained from the Current by
    erasing some basic terms and constructors (see
    also SorensenGlueck1995 , Leuschel1998).
  • If the set of the basic terms is reasonable
    enough, then any infinite term sequence tn ?
    positive-pd has a pair ti, tk such that k gt i and
    tk is not less complex compared to ti.

20
Global analysis - I (derivation of the output
formats)
  • Derivation of the output formats is critical
    when the length of the function stack of a
    program to be transformed is not uniformly
    bounded on the input data. Without such
    derivation interesting transformations are not
    happening.
  • ENTRY Go e.n ltFact (e.n)gt
  • Fact ( ) (I)
  • (e.n) (ltTimes (e.n) ltFact (ltMinus
    (e.n) (I)gt)gtgt)
  • Times (e.u) ( )
  • (e.u) (I e.v) ltPlus (ltTimes (e.u)
    (e.v)gt) (e.u)gt
  • Plus (e.u) ( ) e.u
  • (e.u) (I e.v) I ltPlus (e.u) (e.v)gt
  • Minus (I e.u) (I e.v) ltMinus (e.u) (e.v)gt
  • (e.u) ( ) e.u
    ltF7 e.1gt
    (ltF7 e.1gt)
  • (Input Format e.1)
  • F7
    F7
  • ( I )
    I
  • I e.1 ( ltF16 e.1, e.3gt ),
    I e.1 ltF16 e.1, ltF7 e.1gtgt
  • where ltF7 e.1gt (e.3)
  • (Output Format (e.6) )

21
Global analysis - II (derivation of the output
formats)
Example Specialization of the following function
Plus w.r.t. the second argument is not a
surprise. Plus (e.u) ( ) e.u
(e.u) (I e.v) I ltPlus (e.u) (e.v)gt Let us
specialize the function w.r.t. the first argument
by the supercompiler. We input the entry point
ENTRY Go (e.n) (e.m) ltPlus (I e.n) (e.m)gt
to Scp4. The residual program looks as
follows. ENTRY Go (e.n) (e.m) I ltF7 (e.n)
e.mgt F7 (e.1) e.1 (e.1) I e.2
I ltF7 (e.1) e.2gt
22
An simple example supercompilation manually
Given the following program rev1 and the
parameterized entry to the program
A ltrev2 e.1 ()gt rev2 t.6 e.7 (e.5) ltrev2 e.7
(t.6 e.5)gt (e.5) e.5
ltrev1 e.1 A ()gt rev1 t.x e.ys (e.res) ltrev1
e.ys (t.x e.res)gt (e.res) e.res
ltrev1 e.1 A ()gt
e.4 e.1 e.5
generalization
ltrev1 e.4 A (e.5)gt
e.1 ?
e.1?t.2 e.3
ltrev1 (A)gt
e.4 ?
ltrev1 (A e.5)gt
e.4?t.6 e.7
ltrev1 e.3 A (t.2)gt
ltrev1 e.7 A (t.6 e.5)gt
A e.5
e.4 e.7 e.5 t.6 e.5
reducing
23
Scp4 as a simple theorem prover
  • Problem after L. F. Magnitckij A flock of geese
    is flying, and it meets a single
  • gander. The gander says How do you do, one
    hundred geese? The flock leader
  • answers we are not one hundred. Well, if
    one will count all of us, and as
  • many again, and a half-many again, and a quarter
    of us, and also you, Gander, then
  • the amount will be exactly one hundred.
  • The question How many geese are in the flock?
  • ENTRY Go e.n ltEq (ltCounter e.ngt)
    (ltHundredgt)gt
  • Eq ( ) ( ) TRUE
  • ('g' e.xs) ('g' e.ys) ltEq (e.xs) (e.ys)gt
  • (e.xs) (e.ys) FALSE
  • Hundred 'gggggggggggggggggggggggggggggggggggg
    gggggggggggggg'
  • 'ggggggggggggggggggggggggggg
    ggggggggggggggggggggggg'
  • Counter 'gggg' e.n 'gggg' 'gggg' 'gg' 'g'
    ltCounter e.ngt
  • 'g'

Here 'gg' 'g' 'g'
24
The question How many geese are in the flock?
  • The answer given by Scp4 / use
    geese.ref for demonstration /
  • ENTRY Go
  • 'gggggggggggggggggggggggggggggggggggggggg' e.n
    FALSE
  • The following string has 36 of 'g' (of geese).
  • 'gggggggggggggggggggggggggggggggggggg' TRUE
  • 'gggggggggggggggggggggggggggggggg' FALSE
  • The length of the (n3)-th left side is
    36-4(n1),
  • while the right side is FALSE.
  • ...
  • FALSE
  • We not only have found the answer but also proved
    that no other solution exists.
  • Mathematical induction on e.n happens during
    supercompilation and
  • the recursions written in the original program
    were eliminated.

25
More adequate method for the Counter.
  • Counter e.n ltAll e.ngt ltAll e.ngt ltHalf
    e.ngt ltQuoter e.ngt 'g'
  • All e.n e.n
  • Half
  • 'gg' e.n 'g' ltHalf e.ngt
  • Quoter
  • 'gggg' e.n 'g' ltQuoter e.ngt
  • The residual program looks akin to the one
    given above and has one
  • hundred sentences.

26
SCP4 as a simple theorem prover. (II)
  • The task / use palindrome.ref for
    demonstration /
  • ENTRY Go e.ls ltpalindrome e.ls ltrev e.lsgtgt
  • palindrome True
  • s.x True
  • s.x e.ls s.x ltpalindrome e.lsgt
  • s.x e.ls s.y False
  • rev
  • t.x e.ls ltrev e.lsgt t.x
  • The result of specialization A simple theorem
    has been proven.
  • ENTRY Go
  • True
  • s.102 e.41 True

27
Using of SCP4 for theorem proving
and simplification of definitions.
  • The problem Resolve the following equation 'a'
    X X 'a', where the variable X
  • ranges on strings. / use refal.ref for
    demonstration /
  • ENTRY Go e.x ltEq ('a' e.x) (e.x 'a')gt
  • Eq
  • (s.1 e.x) (s.1 e.y) ltEq (e.x) (e.y)gt
  • ((e.1) e.x) ((e.2) e.y) ltEq (e.1 e.x) (e.2
    e.y)gt
  • () () True
  • (e.x) (e.y) False
  • The simplified definition given by SCP4. A
    simple theorem has been proven.
  • ENTRY Go e.41 ltF7 e.41 gt
  • F7
  • 'a' e.41 ltF7 e.41 gt
  • True
  • e.41 False

28
Specialization of composition and removing
recursion.
  • The program / use replace.ref for
    demonstration /
  • repl s.a s.b ( )
  • s.a s.b (s.a e.xs) s.b ltrepl s.a
    s.b (e.xs)gt
  • s.a s.b (s.c e.xs) s.c ltrepl s.a
    s.b (e.xs)gt
  • The task 1
  • ENTRY Go e.xs ltrepl B C (ltrepl A B
    (e.xs)gt)gt
  • The task 2
  • ENTRY Go
  • (s.b s.c) (s.a s.b) e.xs ltrepl s.b s.c (ltrepl
    s.a s.b (e.xs)gt)gt
  • The task 3
  • ENTRY Go
  • (s.a s.a) (s.a s.a) e.xs ltrepl s.a s.a
    (ltrepl s.a s.a (e.xs)gt)gt

29
Specialization of composition. (I)
  • The program / use replace.ref for
    demonstration /
  • repl s.a s.b ( )
  • s.a s.b (s.a e.xs) s.b ltrepl s.a
    s.b (e.xs)gt
  • s.a s.b (s.c e.xs) s.c ltrepl s.a
    s.b (e.xs)gt
  • ENTRY Go e.xs ltrepl B C (ltrepl A B
    (e.xs)gt)gt
  • The result contains just one loop over the
    string.
  • ENTRY Go e.41 ltF7 e.41 gt
  • F7
  • A e.41 C ltF7 e.41 gt
  • B e.41 C ltF7 e.41 gt
  • s.101 e.41 s.101 ltF7 e.41 gt

30
Specialization of composition. (II)
  • The program / use replace.ref for
    demonstration /
  • repl s.a s.b ( )
  • s.a s.b (s.a e.xs) s.b ltrepl s.a
    s.b (e.xs)gt
  • s.a s.b (s.c e.xs) s.c ltrepl s.a
    s.b (e.xs)gt
  • ENTRY Go (s.b s.c) (s.a s.b) e.xs ltrepl s.b
    s.c (ltrepl s.a s.b (e.xs)gt)gt
  • The result again contains just one loop over
    the string.
  • ENTRY Go
  • (s.102 s.103 ) (s.105 s.102 ) e.41 ltF7 (e.41
    ) s.102 s.103 s.105 gt
  • F7
  • () s.102 s.103 s.105
  • (s.105 e.41 ) s.102 s.103 s.105 s.103 ltF7
    (e.41 ) s.102 s.103 s.105 gt
  • (s.102 e.41 ) s.102 s.103 s.105 s.103 ltF7
    (e.41 ) s.102 s.103 s.105gt
  • (s.107 e.41 ) s.102 s.103 s.105 s.107 ltF7
    (e.41 ) s.102 s.103 s.105gt

31
Specialization of composition. (III)
  • The program / use replace.ref for
    demonstration /
  • repl s.a s.b ( )
  • s.a s.b (s.a e.xs) s.b ltrepl s.a
    s.b (e.xs)gt
  • s.a s.b (s.c e.xs) s.c ltrepl s.a
    s.b (e.xs)gt
  • ENTRY Go (s.a s.a) (s.a s.a) e.xs ltrepl s.a
    s.a (ltrepl s.a s.a (e.xs)gt)gt
  • The result contains no loops at all. The time
    complexity was decreased.
  • ENTRY Go
  • (s.102 s.102 ) (s.102 s.102 ) e.41 e.41

32
"The House That Jack Built" by Jonathan Swift.
  • The program exploits the recursion given in the
    poetry. The idea belongs to
  • Alexandr Korljukov. / use swift.ref for
    demonstration /
  • ENTRY Go ltTitlegt ltJonathanSwiftgt
  • Title ltParagraphgt
  • ' The House That Jack
    Built' ltNLgt
  • ' Jonathan Swift'
    ltNLgt
  • Paragraph ltNLgt ltNLgt
  • NL '\n'
  • Scene "This is" 'the farmer
    sowing the corn,' " " ltNLgt
  • "That" "kept" 'the
    cock that crowed in the morn,' ltNLgt
  • "That" "waked" 'the
    priest all shaven and shorn,' ltNLgt
  • "That" "married" 'the man
    all tattered and torn,' ltNLgt
  • "That" "kissed" 'the
    maiden all forlorn,' ltNLgt
  • "That" "milked" 'the cow
    with the crumpled horn,' ltNLgt
  • "That" "tossed" 'the
    dog,' ltNLgt
  • "That" "worried" 'the
    cat,' ltNLgt
  • "That" "killed" 'the
    rat,' ltNLgt
  • "That" "ate" 'the
    malt' ltNLgt
  • "That" "lay" 'in the
    house that Jack built.' ltNLgt

33
Ackermans function
Consider a definition of Ackermanns function for
the unary arithmetic.
ltAck (e.m) (e.n)gt Ack () (e.n) I
e.n (I e.m) () ltAck (e.m) (I)gt (I e.m)
(I e.n) ltAck (e.m) (ltAck (I e.m) (e.n)gt)gt
Specialization by the supercompiler Scp4
gives With respect to ENTRY Go e.n ltAck
() (e.n)gt  ENTRY Go e.n I e.n With
respect to ENTRY Go e.n ltAck (I) (e.n)gt
ENTRY Go e.n I I e.n With respect
to Go e.n ltAck (I I) (e.n)gt ENTRY Go
e.n I I I ltF7 e.n gt  F7 I
e.1 I I ltF7 e.1 gt
34
Specialization of interpreters.
ltIntL ( Program ) e.data gt
ltGO
gt An interpreter IntL of a programming
language L is specialized with respect to a given
program. IntL is written in a language M, while
the program is written in L, so we expect an
optimal program written in M as a result of
specialization. Thus a specializer may be used as
a compiler from L into M, where M is the subject
language of the specializer.
35
Self-description
  • Syntax of an algorithmically full subset of the
    Refal language.
  • Program ENTRY definition
  • definition function-name sentence
  • sentence pattern expr
  • expr empty term expr1 function-call
    expr1
  • function-call ltfunction-name exprgt
  • pattern empty term pattern1
  • term SYMBOL var (expr)
  • var e.name t.name s.name
  • empty
    / nihil /
  • There are two additional restrictions
  • the set of the variables of the right side of a
    sentence is a subset of the variable set of the
    left side of the sentence
  • two e-variables are not allowed on the same
    parenthesis structure in the patterns. (For
    example, the pattern (e.1) e.2 (e.3) is allowed,
    while (e.1 A e.2) e.3 is not.)

36
Specialization of the interpreter (I)
Example 1
Example 2 (Refal style reversing)
The task ltInt Palindrome e.datagt
The task ltInt rev e.datagt
Palindrome True   s.1 True  
s.1 e.2 s.1 ltPalindrome e.2gt  e.1 False
rev t.x e.ys ltrev e.ysgt t.x

The residual program
The residual program
InputFormat ltF27 e.data gt F27 t.4 e.1
ltF27 e.1 gt t.4
InputFormat ltF27 e.data gt F27 True
s.5 True s.4 e.1 s.4 ltF27 e.1 gt
e.1 False
37
Specialization of the interpreter (II)
Example 3 (Lisp style reversing)
The task ltInt Go-rev1 e.datagt
ENTRY Go e.ys ltrev1 e.ys ()gt rev1 t.x
e.ys (e.res) ltrev1 e.ys (t.x e.res)gt
(e.res) e.res
The residual program
ENTRY Go e.data ltF80 () e.datagt
InputFormat ltF80 (e.1) e.2gt F80 (e.1) t.6 e.2
ltF80 (t.6 e.1 ) e.2gt (e.1) e.1
38
Specialization of the interpreter (III)
Example 4 (The following program replaces every
occurrence of the identifier Lisp with the
identifier Refal in an arbitrary Refal datum.)
The task ltInt Go-Replace e.datagt
ENTRY Go e.where ltReplace (Lisp Refal)
e.wheregt Replace (s.what e.value)
(s.what e.value) s.what e.where e.value
ltReplace (s.what e.value) e.wheregt (s.what
e.value) s.y e.where s.y ltReplace (s.what
e.value) e.wheregt (s.what e.value) (e.y)
e.where (ltReplace (s.what e.value) e.ygt)
 ltReplace (s.what e.value) e.wheregt
ENTRY Go e.data ltF42 e.datagt
InputFormat ltF42 e.1gt F42 Lisp
e.1 Refal ltF42 e.1gt s.4 e.1
s.4 ltF42 e.1gt ('' e.2) e.1 ('' ltF42 e.2gt)
ltF42 e.1gt
The residual program.
39
Interpreter of the Turing Machine written in
Refal (I)
  • ltTuring (e.Program) (s.CurrentState)
    (e.LeftPartOfTape)

  • (s.CurrentSymbol)(e.RightPartOfTape)gt
  • Turing
  • (e.instr) (stop) (e.left) (s.symbol) (e.right)
    (e.left) (s.symbol) (e.right) 
  • (e.instr) (s.q) (e.left) (s.symbol) (e.right)
  • ltTuring (e.instr) ltTuring1

  • ltSearch (s.q s.symbol) (e.instr)gt

  • (e.left) (s.symbol) (e.right)gt gt

40
Interpreter of the Turing Machine written in
Refal (II)
  • Turing1
  • (s.c s.r left) ( ) (s.symbol)
    (e.right) (s.r) ( ) (B) (s.c e.right)
  • (s.c s.r left) (e.left s.a) (s.symbol) (e.right)
    (s.r) (e.left) (s.a) (s.c e.right)
  • (s.c s.r right) (e.left) (s.symbol) ( )
    (s.r) (e.left s.c) (B) ( )
  • (s.c s.r right) (e.left) (s.symbol) (s.a
    e.right) (s.r) (e.left s.c) (s.a) (e.right)
  • Search
  • (s.key1 s.key2) ((s.key1 s.key2 e.value) e.table)
    (e.value)
  • (s.key1 s.key2) ((e.row) e.table)  ltSearch
    (s.key1 s.key2) (e.table)gt

41
Program for the Turing Machine
  • The program DoublePQ replaces an array of the
    characters P with another array, where each of
    the Ps was changed with two Qs.
  • We are going to specialize the interpreter of the
    TM with respect to this program.

42
The first Futamura projection by the
supercompiler Scp4 (I)
  • ENTRY Go
  • (e.Left) (s.Symbol) (e.Right) ltF6 (e.Left)
    s.Symbol e.Rightgt  
  • F59
  • () () Q (Q Q Q B) (B) ()
  • () (s.3 e.4) Q ltF6 (Q Q Q) s.3 e.4 gt
  • (e.1 s.5) (e.4) Q ltF59 (e.1) (Q e.4) s.5 gt
  • (e.1) () B (e.1 Q Q B) (B) ()
  • (e.1) (s.3 e.4) B ltF6 (e.1 Q Q) s.3 e.4 gt
  • F6
  • (e.1) B  (e.1 B) (B) ()
  • (e.1) B s.5 e.4 (e.1 B) (s.5) (e.4)
  • (e.1) Q  (e.1 Q B) (B) ()
  • (e.1) Q s.5 e.4 ltF6 (e.1 Q) s.5 e.4 gt
  • () P  (Q Q B) (B) ()
  • () P s.5 e.4 ltF6 (Q Q) s.5 e.4 gt
  • (e.1 s.6) P e.4 ltF59 (e.1) (e.4) s.6 gt

43
The first Futamura projection by the
supercompiler Scp4 (II)
  • For our experiment, to see the speedup, we input
    512 of the Ps to the given TM.
  • The original program takes 2 634 778 Refal-steps
    (15.242 seconds) to run, the result of the
    supercompilation takes 525 319 Refal-steps (2.053
    seconds).
  • StepSpeedup 5.016
  • TimeSpeedup 7.388 (for this example and this
    input data).
  • All our experiments were performed under the
    operating system Windows2000 with Intel Pentium-3
    CPU, 262 144 KB RAM, 500 MHz.

44
The first Futamura projection by the
supercompiler Scp4 (III)
  • The tape is infinite in both sides.
  • ENTRY Go (e.Left) (s.Symb) (e.Right) ltF6
    (e.Left) s.Symb e.Right gt
  • F6
  • (e.1) B s.3 e.4 (e.1 B) (s.3) (e.4)
  • (e.1) Q s.3 e.4 ltF6 (e.1 Q) s.3 e.4 gt
  • (e.1 s.2) P e.4 ltF27 (e.1) (e.4) s.2 gt
  • F27
  • (e.1 s.2) (e.4) Q ltF27 (e.1) (Q e.4) s.2 gt
  • (e.1) (s.3 e.4) B ltF6 (e.1 Q Q) s.3 e.4 gt
  •  F6 corresponds to the inner state start, while
    F27 corresponds to the inner state
  • moveleft.  Each sentence corresponds to one
    instruction of the TM. The number
  • of the Refal-steps is equal to the number of the
    TM's steps. The output of the
  • supercompiler is an optimal Refal-program, i.e. a
    compilation of the program
  • for the TM into a Refal-program took place.

45
Supercompilation of an XSLT-interpreter (I)
  • The first Futamura projection
  • Specialization of an XSLT-interpreter written in
    Refal-5 with respect to a given XSLT-program.
  • The given program is an interpreter of the Turing
    Machine written in the language XSLT.
  • We supercompile the task when concrete Turing
    Machines are given.

46
Supercompilation of an XSLT-interpreter (II)
47
References
1 Nemytykh A.P., and Turchin V.F. The
Supercompiler Scp4 sources, on-line
demonstration. ( Free ) http//www.botik.ru/pub/l
ocal/scp/refal5/ ,2000. 2 Turchin, V. F.,
The concept of a supercompiler, ACM Transactions
on Programming Languages and Systems, 1986,
8292-325. 3 Nemytykh A.P., The
Supercompiler Scp4 General Structure., LNCS vol.
2890, pp.162-170, 2003. 4 Nemytykh
A.P., A Note on Elimination of Simplest
Recursions. In Proceedings of the ACM
SIGPLAN Asia-PEPM'02, 138-146. ACM Press, 2002.
5 Korlyukov A.V., and Nemytykh A.P.,
Supercompilation of Double Interpretation.
(How One Hour of the Machine's Time Can Be Turned
to One Second). (In English), Vestnik
natcionalnogo tekhnicheskogo universiteta
Kharkovskogo politekhnicheskogo
instituta, Kharkov, No. 1, 2004. 6
Nemytykh A.P., Playing on REFAL., In Proceedings
of the International Workshop on Program
Understanding, pp29-39, 2003, A.P. Ershov
Institute of Informatics Systems, Siberian
Branch of Russian Academy of Sciences,
Novosibirsk Altai Mountains, Russia.

48

Thank you!
About PowerShow.com