Program specialization by supercompilation The supercompiler Scp 4

Program specialization by supercompilation. (The supercompiler Scp 4. ) Andrei P. Nemytykh Program System Institute, Russian Academy of Sciences, Senior Researcher http: //www. botik. ru/PSI/RCMS/APP/nemytykh. html http: //www. botik. ru/pub/local/scp/refal 5/nemytykh_cv. html

State of art of program transformation w During the last three decades the following most promising program transformation methods have been under development: 1. 2. 3. 4. 5. 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.

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 1. 2. interpretation of specialized application-oriented languages and component programming from libraries of general re-usable software, etc. 3. Thus, the methods are directed to provide degrees of freedom for new software technologies rather than to optimizing programs written in an old style.

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.

A number of tasks for specialization. <F x 0, y> The first argument of a program F is given, while the second is unknown. <F <G x, y> , z > 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. <Int. L ( Program ) e. data <GO > > An interpreter Int. L of a programming language L is specialized with respect to a given program. Int. L 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.

What is supercompilation ? • Supercompilation is a technique of specialization of programs written in a functional programming language. The technique was introduced in the 1970 s 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.

The Supercompiler SCP 4 • is an experimental specializer for a functional language Refal-5. (There are no special restrictions on the input language. ) Scp 4 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/scp/refal 5/ (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 Scp 4 by Alexandr V. Korlyukov (in Russian). • Alexandr P. Konyshev implemented a compiler from the intermediate Scp 4’s language into the language C.

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 : : = (d 1) | d 1 d 2 | SYMBOL | empty : : = /* nothing */ Example: (A + B) * (C – D) * A + B C - D

The language REFAL (the first example definition) * Concatenation is associative. $ENTRY Go { e. xs = <repl B A (<repl A B (e. xs)>)>; } -- 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 <repl s. a s. b (e. xs)>; -- 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))

An introduction to REFAL (associative concatenation) Example 1: * The palindrome predicate: Palindrome { = True; s. 1 = True; -- application constr. s. 1 e. 2 s. 1 = <Palindrome e. 2>; e. 1 = False; } /* Pattern may be split from both sides: a symbol-variable s. 1 is split from the left and right sides. */ Example 2: (Refal style reversing) * Reversing a list of terms: rev { t. x e. ys = <rev e. ys> 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. */

The language REFAL (data processing) * Concatenation is associative. $ENTRY Go { s. a e. xs = <replace s. a (e. xs)>; } 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 <replace s. a s. b (e. xs)>; s. a s. b (s. x e. xs) = s. x <replace s. a s. b (e. xs)>; s. a s. b ((e. ys) e. xs) = (<replace s. a s. b (e. ys) >) <replace s. a s. b (e. xs)>; } 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))

What is supercompilation ? • Supercompilation is a technique of specialization of programs written in a functional programming language. The technique was introduced in the 1970 s 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;

General structure of the Refal interpreter Entry config. Refal-5 Source prog. Internal task final language inp. -prog. result : = ; /* undefined */ do { Refal-step; } while( the task is not solved ) /* still is not completely evaluated */ if( the task is determined ) { result : = task; } Refal-5 Result

General structure of SCP 4 Parameterized entry config. -s Internal language Refal-5 Source program tasks final input program 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; Refal-5 parameterized entry points, residual program C

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 driving a =? 0 a x + b = 0 b =? 0 b ? 0 a ? 0 x = -b/a; a 0 any x ℝ Ø

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

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). Previous top Current top Context Middle Context 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 = Previous. Top; Context; Current = Current. Top; 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 ( Previous. Top = F 1 ptime_1, …, FNptime_n Current. Top = F 1 ctime_1, …, FNctime_n ) coincide modulo the creation times. The Context determines computations immediately after the loop.

Obninsk condition (example) Consider a definition of the unary factorial. $ENTRY Inc. Fact {e. n = <Plus (I) (<Fact (e. n)>)>; } Fact { ( ) = I; (e. n) = <Times (e. n) (<Fact (<Minus (e. n) (I)>)>)>; } Times { (e. u) ( ) = ; (e. u) (I e. v) = <Plus (<Times (e. u) (e. v)>) (e. u)>; } Plus { (e. u) ( ) = e. u; (e. u) (I e. v) = I <Plus (e. u) (e. v)>; } Minus { (I e. u) (I e. v) = <Minus (e. u) (e. v)>; (e. u) ( ) = e. u; } "Lazy" development of the stack along the main branch yields the following sequence: [1]: Inc. Fact 1; [2]: Plus 2; A hypothesis is that the stack [3]: Fact 4; Plus 3; will further have the form [4]: Times 5; Plus 3; Fact; Timesn; Plus 3; [5]: Fact 7; Times 6; Plus 3; … The stack formed on the fifth step is "similar" to the stack created on the third step.

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 Sorensen&Glueck: 1995 , Leuschel: 1998). • 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 > i and tk is not less complex compared to ti.

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 = <Fact (e. n)>; } Fact { ( ) = (I); (e. n) = (<Times (e. n) <Fact (<Minus (e. n) (I)>)>>); } Times { (e. u) ( ) = ; (e. u) (I e. v) = <Plus (<Times (e. u) (e. v)>) (e. u)>; } Plus { (e. u) ( ) = e. u; (e. u) (I e. v) = I <Plus (e. u) (e. v)>; } Minus { (I e. u) (I e. v) = <Minus (e. u) (e. v)>; (e. u) ( ) = e. u; } <F 7 e. 1> (<F 7 e. 1>) (Input Format: e. 1) F 7 { F 7 { = ( I ); = I; I e. 1 = ( <F 16 e. 1, e. 3> ), I e. 1 = <F 16 e. 1, <F 7 e. 1>>; where <F 7 e. 1>: (e. 3); } } (Output Format: (e. 6) )

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 <Plus (e. u) (e. v)>; } 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) = <Plus (I e. n) (e. m)>; } to Scp 4. The residual program looks as follows. $ENTRY Go { (e. n) (e. m) = I <F 7 (e. n) e. m>; } F 7 { (e. 1) = e. 1; (e. 1) I e. 2 = I <F 7 (e. 1) e. 2>; }

An simple example: supercompilation manually Given the following program rev 1 and the parameterized entry to the program: <rev 1 e. 1 A ()> rev 1 { t. x e. ys (e. res) = <rev 1 e. ys (t. x e. res)>; (e. res) = e. res; } e. 4 : = e. 1; e. 5 : = ; <rev 1 e. 1 A ()> e. 1→t. 2 e. 3; A <rev 2 e. 1 ()> rev 2 { t. 6 e. 7 (e. 5) = <rev 2 e. 7 (t. 6 e. 5)>; (e. 5) = e. 5; } e. 1 → ; <rev 1 (A)> <rev 1 e. 4 A (e. 5)> e. 4→t. 6 e. 7; <rev 1 e. 3 A (t. 2)> generalization e. 4 → ; <rev 1 (A e. 5)> <rev 1 e. 7 A (t. 6 e. 5)> e. 4 : = e. 7; e. 5 : = t. 6 e. 5; reducing A e. 5

Scp 4 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? Here 'gg' : = 'g' $ENTRY Go { e. n = <Eq (<Counter e. n>) (<Hundred>)>; } Eq { ( ) = TRUE; ('g' e. xs) ('g' e. ys) = <Eq (e. xs) (e. ys)>; (e. xs) (e. ys) = FALSE; } Hundred { = 'ggggggggggggggggggggggggg' 'ggggggggggggggggggggggggg' ; } Counter { 'gggg' e. n = 'gggg' 'gg' 'g' <Counter e. n>; = 'g'; }

The question: How many geese are in the flock? The answer given by Scp 4: /* use geese. ref for demonstration */ $ENTRY Go { 'gggggggggggggggggggg' e. n = FALSE ; * The following string has 36 of 'g' (of geese). 'gggggggggggggggggg' = TRUE ; 'gggggggggggggggg' = FALSE ; * The length of the (n+3)-th left side is 36 -4(n+1), * 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.

More adequate method for the Counter { e. n = <All e. n> <Half e. n> <Quoter e. n> 'g'; } All { e. n = e. n; } Half { = ; 'gg' e. n = 'g' <Half e. n>; } Quoter { = ; 'gggg' e. n = 'g' <Quoter e. n>; } The residual program looks akin to the one given above and has one hundred sentences.

SCP 4 as a simple theorem prover. (II) The task: /* use palindrome. ref for demonstration */ $ENTRY Go { e. ls = <palindrome e. ls <rev e. ls>>; } palindrome { = True; s. x = True; s. x e. ls s. x = <palindrome e. ls>; s. x e. ls s. y = False; } rev { = ; t. x e. ls = <rev e. ls> t. x; } The result of specialization: A simple theorem has been proven. $ENTRY Go { = True ; s. 102 e. 41 = True ; }

Using of SCP 4 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 = <Eq ('a' e. x) (e. x 'a')>; } Eq { (s. 1 e. x) (s. 1 e. y) = <Eq (e. x) (e. y)>; ((e. 1) e. x) ((e. 2) e. y) = <Eq (e. 1 e. x) (e. 2 e. y)>; () = True; (e. x) (e. y) = False; } The simplified definition: given by SCP 4. A simple theorem has been proven. $ENTRY Go { e. 41 = <F 7 e. 41 > ; } F 7 { 'a' e. 41 = <F 7 e. 41 > ; = True ; e. 41 = False ; }

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 <repl s. a s. b (e. xs)>; s. a s. b (s. c e. xs) = s. c <repl s. a s. b (e. xs)>; } The task #1: $ENTRY Go {e. xs = <repl B C (<repl A B (e. xs)>)>; } The task #2: $ENTRY Go { (s. b s. c) (s. a s. b) e. xs = <repl s. b s. c (<repl s. a s. b (e. xs)>)>; } The task #3: $ENTRY Go { (s. a) e. xs = <repl s. a (e. xs)>)>; }

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 <repl s. a s. b (e. xs)>; s. a s. b (s. c e. xs) = s. c <repl s. a s. b (e. xs)>; } $ENTRY Go {e. xs = <repl B C (<repl A B (e. xs)>)>; } The result: contains just one loop over the string. $ENTRY Go { e. 41 = <F 7 e. 41 > ; } F 7 { = ; A e. 41 = C <F 7 e. 41 > ; B e. 41 = C <F 7 e. 41 > ; s. 101 e. 41 = s. 101 <F 7 e. 41 > ; }

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 <repl s. a s. b (e. xs)>; s. a s. b (s. c e. xs) = s. c <repl s. a s. b (e. xs)>; } $ENTRY Go {(s. b s. c) (s. a s. b) e. xs = <repl s. b s. c (<repl s. a s. b (e. xs)>)>; } The result: again contains just one loop over the string. $ENTRY Go { (s. 102 s. 103 ) (s. 105 s. 102 ) e. 41 = <F 7 (e. 41 ) s. 102 s. 103 s. 105 > ; } F 7 { () s. 102 s. 103 s. 105 = ; (s. 105 e. 41 ) s. 102 s. 103 s. 105 = s. 103 <F 7 (e. 41 ) s. 102 s. 103 s. 105 >; (s. 102 e. 41 ) s. 102 s. 103 s. 105 = s. 103 <F 7 (e. 41 ) s. 102 s. 103 s. 105>; (s. 107 e. 41 ) s. 102 s. 103 s. 105 = s. 107 <F 7 (e. 41 ) s. 102 s. 103 s. 105>; }

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 <repl s. a s. b (e. xs)>; s. a s. b (s. c e. xs) = s. c <repl s. a s. b (e. xs)>; } $ENTRY Go {(s. a) e. xs = <repl s. a (e. xs)>)>; } The result: contains no loops at all. The time complexity was decreased. $ENTRY Go { (s. 102 ) e. 41 = e. 41 ; }

"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 { = <Title> <Jonathan. Swift>; } Title { = <Paragraph> ' The House That Jack Built' <NL> ' Jonathan Swift' <NL>; } Paragraph { = <NL>; } NL { = 'n'; } Scene { = "This is" 'the farmer sowing the corn, ' " " <NL> "That" "kept" 'the cock that crowed in the morn, ' <NL> "That" "waked" 'the priest all shaven and shorn, ' <NL> "That" "married" 'the man all tattered and torn, ' <NL> "That" "kissed" 'the maiden all forlorn, ' <NL> "That" "milked" 'the cow with the crumpled horn, ' <NL> "That" "tossed" 'the dog, ' <NL> "That" "worried" 'the cat, ' <NL> "That" "killed" 'the rat, ' <NL> "That" "ate" 'the malt' <NL> "That" "lay" 'in the house that Jack built. ' <NL>; } Jonathan. Swift { = <Loop <Scene>>; } Loop { "This is" 'in the house that Jack built. ' e. 1 = <Paragraph> "This is" 'the house that Jack built. ' e. 1; e. Couplet = <Next e. Couplet> <Paragraph> e. Couplet; } Next { s. This 'n' s. That s. verb e. text = <Loop s. This e. text>; s. This s. Char e. text = <Next s. This e. text>; s. This = ; }

Ackerman’s function Consider a definition of Ackermann’s function for the unary arithmetic. * <Ack (e. m) (e. n)> Ack { () (e. n) = I e. n; (I e. m) () = <Ack (e. m) (I)>; (I e. m) (I e. n) = <Ack (e. m) (<Ack (I e. m) (e. n)>)>; } Specialization by the supercompiler Scp 4 gives: *With respect to: $ENTRY Go { e. n = <Ack () (e. n)>; } $ENTRY Go { e. n = I e. n ; } *With respect to: $ENTRY Go { e. n = <Ack (I) (e. n)>; } $ENTRY Go { e. n = I I e. n ; } *With respect to: Go { e. n = <Ack (I I) (e. n)>; } $ENTRY Go { e. n = I I I <F 7 e. n > ; } F 7 { = ; I e. 1 = I I <F 7 e. 1 > ; }

Specialization of interpreters. <Int. L ( Program ) e. data <GO > > An interpreter Int. L of a programming language L is specialized with respect to a given program. Int. L 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.

Self-description Syntax of an algorithmically full subset of the Refal language. Program : : = $ENTRY definition+ definition : : = function-name { sentence; + } sentence : : = pattern = expr : : = empty | term expr 1 | function-call expr 1 function-call : : = <function-name expr> pattern : : = empty | term pattern 1 term : : = SYMBOL | var | (expr) var : : = e. name | t. name | s. name empty : : = /* nihil */ There are two additional restrictions: 1) 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; 2) 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. )

Specialization of the interpreter (I) Example 1: The task: <Int Palindrome e. data> Palindrome { = True; s. 1 e. 2 s. 1 = <Palindrome e. 2>; e. 1 = False; } The residual program: * Input. Format: <F 27 e. data > F 27 { = True ; s. 5 = True ; s. 4 e. 1 s. 4 = <F 27 e. 1 > ; e. 1 = False ; } Example 2: (Refal style reversing) The task: <Int rev e. data> rev { t. x e. ys = <rev e. ys> t. x; =; } The residual program: * Input. Format: <F 27 e. data > F 27 { t. 4 e. 1 = <F 27 e. 1 > t. 4 ; = ; }

Specialization of the interpreter (II) Example 3: (Lisp style reversing) The task: <Int Go-rev 1 e. data> $ENTRY Go { e. ys = <rev 1 e. ys ()>; } rev 1 { t. x e. ys (e. res) = <rev 1 e. ys (t. x e. res)>; (e. res) = e. res; } The residual program: $ENTRY Go { e. data = <F 80 () e. data> ; } * Input. Format: <F 80 (e. 1) e. 2> F 80 { (e. 1) t. 6 e. 2 = <F 80 (t. 6 e. 1 ) e. 2> ; (e. 1) = e. 1 ; }

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: <Int Go-Replace e. data> $ENTRY Go { e. where = <Replace (Lisp Refal) e. where>; } Replace { (s. what e. value) = ; (s. what e. value) s. what e. where = e. value <Replace (s. what e. value) e. where>; (s. what e. value) s. y e. where = s. y <Replace (s. what e. value) e. where>; (s. what e. value) (e. y) e. where = (<Replace (s. what e. value) e. y>) <Replace (s. what e. value) e. where>; } $ENTRY Go { e. data = <F 42 e. data> ; } * Input. Format: <F 42 e. 1> F 42 { = ; Lisp e. 1 = Refal <F 42 e. 1> ; s. 4 e. 1 = s. 4 <F 42 e. 1> ; ('*' e. 2) e. 1 = ('*' <F 42 e. 2>) <F 42 e. 1> ; } The residual program.

Interpreter of the Turing Machine written in Refal (I) * <Turing (e. Program) (s. Current. State) (e. Left. Part. Of. Tape) * (s. Current. Symbol)(e. Right. Part. Of. Tape)> 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) = <Turing (e. instr) <Turing 1 <Search (s. q s. symbol) (e. instr)> (e. left) (s. symbol) (e. right)> >; }

Interpreter of the Turing Machine written in Refal (II) Turing 1 { (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. key 1 s. key 2) ((s. key 1 s. key 2 e. value) e. table) = (e. value); (s. key 1 s. key 2) ((e. row) e. table) = <Search (s. key 1 s. key 2) (e. table)>; }

Program for the Turing Machine The program Double. PQ 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.

The first Futamura projection by the supercompiler Scp 4 (I) $ENTRY Go { (e. Left) (s. Symbol) (e. Right) = <F 6 (e. Left) s. Symbol e. Right>; } F 59 { () () Q = (Q Q Q B) () ; () (s. 3 e. 4) Q = <F 6 (Q Q Q) s. 3 e. 4 > ; (e. 1 s. 5) (e. 4) Q = <F 59 (e. 1) (Q e. 4) s. 5 > ; (e. 1) () B = (e. 1 Q Q B) () ; (e. 1) (s. 3 e. 4) B = <F 6 (e. 1 Q Q) s. 3 e. 4 > ; } F 6 { (e. 1) B = (e. 1 B) () ; (e. 1) B s. 5 e. 4 = (e. 1 B) (s. 5) (e. 4) ; (e. 1) Q = (e. 1 Q B) () ; (e. 1) Q s. 5 e. 4 = <F 6 (e. 1 Q) s. 5 e. 4 > ; () P = (Q Q B) () ; () P s. 5 e. 4 = <F 6 (Q Q) s. 5 e. 4 > ; (e. 1 s. 6) P e. 4 = <F 59 (e. 1) (e. 4) s. 6 > ; }

The first Futamura projection by the supercompiler Scp 4 (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). • Step. Speedup = 5. 016 • Time. Speedup = 7. 388 (for this example and this input data). • All our experiments were performed under the operating system Windows 2000 with Intel Pentium-3 CPU, 262 144 KB RAM, 500 MHz.

The first Futamura projection by the supercompiler Scp 4 (III) * The tape is infinite in both sides. $ENTRY Go { (e. Left) (s. Symb) (e. Right) = <F 6 (e. Left) s. Symb e. Right > ; } F 6 { (e. 1) B s. 3 e. 4 = (e. 1 B) (s. 3) (e. 4) ; (e. 1) Q s. 3 e. 4 = <F 6 (e. 1 Q) s. 3 e. 4 > ; (e. 1 s. 2) P e. 4 = <F 27 (e. 1) (e. 4) s. 2 > ; } F 27 { (e. 1 s. 2) (e. 4) Q = <F 27 (e. 1) (Q e. 4) s. 2 > ; (e. 1) (s. 3 e. 4) B = <F 6 (e. 1 Q Q) s. 3 e. 4 > ; } F 6 corresponds to the inner state start, while F 27 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.

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

Supercompilation of an XSLTinterpreter (II)

References [1] Nemytykh A. P. , and Turchin V. F. The Supercompiler Scp 4: sources, on-line demonstration. ( Free ) http: //www. botik. ru/pub/local/scp/refal 5/ , 2000. [2] Turchin, V. F. , The concept of a supercompiler, ACM Transactions on Programming Languages and Systems, 1986, 8: 292 -325. [3] Nemytykh A. P. , The Supercompiler Scp 4: 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 natcional’nogo tekhnicheskogo universiteta “Khar’kovskogo politekhnicheskogo instituta”, Khar’kov, No. 1, 2004. [6] Nemytykh A. P. , Playing on REFAL. , In Proceedings of the International Workshop on Program Understanding, pp: 29 -39, 2003, A. P. Ershov Institute of Informatics Systems, Siberian Branch of Russian Academy of Sciences, Novosibirsk – Altai Mountains, Russia.

Thank you!