A Model Of CPS Translation And Interpretation

Size: px

Start display at page:

Download "A Model Of CPS Translation And Interpretation"

Dwight Joseph
5 years ago
Views:

1 A Model Of CPS Translation And Interpretation Ramon Zatara R. Stansifer Departamento de Sistemas y Computación Computer Science Department Instituto Tenológico de Culiacán Florida Institute of Technology Av. Juan de Dios Bátiz s/n. Col. Guadalupe University Blvd. Melbourne, FL Culiacán, S, México. CP Tel Phone Fax rzatara@itculiacan.edu.mx, ryan@cs.fit.edu ABSTRACT This paper presents a model of translation of functional languages. The source language of the translation is a simple extension of lambda expressions and the target language is a language contuation passg style (CPS). We have implemented, SML [5], the translation and the terpreters of both the source and target languages. These systems are based on the defitions of the CPS semantics by Appel [1]. The ma contribution is a compe and executable framework for a CPS compiler, allowg the study of a wide range of performance issues among different elements. Another contribution is the implementation of a succeed and fail contuation model. The approach elimates overhead when usg exception handlg and was described [3]. Categories and Subject Descriptors D.3.4 [Programmg Languages]: Processors Compilers. approach of succeed and fail contuation model. The traditional approach uses only one contuation. Figure 1. Model of translation-terpretation Intermediate Representation Of SML programs (Lambda code) Translator To CPS General Terms Algorithms, Measurement, Performance, Experimentation, Languages. Keywords Functional programmg languages, compilers, exception handlg, and contuation-passg style. Input CPS Program Evaluator Of CPS Value 1. INTRODUCTION Contuation-passg style is a style of programmg or a special notation sometimes employed as an termediate representation Functional Programmg compilers [1,2,6]. Its ma idea is to make every aspect of control flow and data flow explicit [1]. A CPS program never needs to use a stack because functions never return. Its ma advantage is, stead of havg a function return a value, a function take as an argument another function to which the result is given as an argument. Another advantage to usg CPS is that every termediate value of a computation is given a name. This allows an easy translation to mache code because every name can correspond to a mache register. However, CPS is not easy to understand. Some people consider it remarkably elusive (too many lambdas they say). Our implementation (translator and terpret) is a tool that allows a user to translate lambda code to CPS code and then execute it (see figure 1), thereby providg, an environment to make different kds of experiments with both (lambda and CPS) styles of programmg. One of the experiments we did was to modify the traditional method to handle exceptions the SML language. In the experiment we implemented an 2. A MINICOMPILER FOR MINI ML The first part of the model shown before, is a translator to CPS. This translator takes a program written a lambda language (encoded to a tree-like data structure), and then makes a recursive traversal over the source-language program producg a CPS program. Our lambda language defition is described the next SML datatype and is similar to Appel defition [1]. 2.1 The Lambda language datatype lexp= VAR of var INT of t STRING of strg FN of var * lexp of var list * lexp list * lexp APP of lexp * lexp PLUS SUB MULT LESS EQ MAKEREF RAISE of lexp HANDLE of lexp * lexp COND of lexp * lexp * lexp (* switch *)

2 2.2 The CPS language The CPS language used our translator has three big differences with respect to those traditional compilers, which use also CPS as an termediate representation [1,2]: Every function has a name. There is an operator for defg mutually recursive functions (stead of fixed pot function). There are n-tuple primitive operators. Besides that, we use the ML datatype declaration order to prohibit ill-formed expressions. One important property of CPS is that every termediate value of a computation is given a name. This makes easier the translation later, to any kd of mache code. For example the SML expression 289 (17 * 17) is translated to (*,[INT 17,INT 17],["w2"], [ (-,[INT 289,VAR "w2"], ["w1"],[app (VAR "k",[var "w1"])])]) CPS notation, where w1 and w2 are termediate names produced by the translator. We will expla more detail later this example. Another important aspect of CPS operations is that every argument is atomic; that means that only variables or constants are allowed to be arguments. The defition of a CPS expression as an ML datatype is shown next code: datatype primop= gethdlr sethdlr + - * < equal makeref datatype value = VAR of var INT of t STRING of strg datatype cexp= APP of value * value list of (var * var list * cexp) list * cexp of primop * value list * var list * cexp list Two examples will clarify our lambda and CPS notation. APP((["fact"], [FN("n", COND(APP(LESS,RECORD [VAR "n",int 1]), INT 1, APP(MULT,RECORD[VAR "n", APP (VAR "fact", APP (SUB,RECORD [VAR "n",int 1]))])))], VAR "fact"),int 6) ([("r29",["x30"],app (VAR "k",[var "x30"]))], ([("fact",["n","w31"], ([("F32",["z33"], (equal,[var "z33",int 0],[], [APP (VAR "w31",[int 1]), ([("r35",["x36"], (*,[VAR "n",var "x36"],["w34"], [APP (VAR "w31",[var "w34"])]))], (-,[VAR "n",int 1],["w37"], [APP (VAR "fact",[var "w37",var "r35"])]))]))], (<,[VAR "n",int 1],[], [APP (VAR "F32",[INT 0]),APP (VAR "F32",[INT 1])])))], APP (VAR "fact",[int 6,VAR "r29"]))) This example corresponds to the classical factorial function. The lambda code is built by usg one function (fact), which bds an anonymous function for the body of the factorial function. The factorial of 6 is evaluated. The CPS expression contas three functions. One is for applyg the identity function (r29); another one for the function factorial; and another one for the condition expression. The ma difference both programs is the way it accumulates the result. In the lambda code, the argument n-1 and a return address are pushed to a stack and then the values and addresses are popped order to get the factorial. But with CPS we do not have return from callg function. The CPS code passes also the argument n-1, but stead of passg the return address, CPS passes a function (name) which contas the rest of the computation (see code italic form). In this case, variable w37 corresponds to the argument n-1 passed to the factorial function, and variable r35 is the function which corresponds to the rest of the computation. Function r35 is an iterative function which computes the factorial by callg itself n number of times. In this case, the call to function w31 is really to function r35, the value bound to r31 (however the last call w31 has value r29, the itial argument passed the first call to function fact, and the last function called the program). (["f"], [FN ("n", HANDLE (APP (MULT,RECORD [VAR "n",var "n"]), FN("e",COND (APP (EQ,RECORD [VAR "e",var "ovfl"]),var "n", RAISE (VAR "e")))))],app (VAR "f",int 1700))

3 ([("f",["n","w55"], (gethdlr,[],["h56"], [ ([("k58",["x67"],app (VAR "w55",[var "x67"])), ("n65",["e57"], (sethdlr,[var "h56"],[], [ ([("F59",["e","k60"], ([("F61",["z62"], (equal,[var "z62",int 0],[], [APP (VAR "k60",[var "n"]), (gethdlr,[],["h63"], [APP (VAR "h63",[var "e"])])]))], (equal,[var "e",var "ovfl"],[], [APP (VAR "F61",[INT 0]), APP (VAR "F61",[INT 1])])))], APP (VAR "F59",[VAR "e57",var "k58"]))]))], (sethdlr,[var "n65"],[], [ (*,[VAR "n",var "n"],["w66"], [ (sethdlr,[var "h56"],[], [APP (VAR "k58",[var "w66"])])])]))]))], ([("r68",["x69"],app (VAR "k",[var "x69"]))], APP (VAR "f",[int 1700,VAR "r68"]))) We will expla the lambda expression handle with more details. This expression has two parts. The first part is the expression that is gog to be evaluated (multiplication expression). The second part is evaluated only if an exception is raised from the first part. The lambda code implements the second part usg an anonymous function with one condition side it. Whenever an exception is raised the first part of the expression, the bound variable (e) of the function takes the exception name, and then the condition expression compares the bound variable (the exception) agast a defed exception (ovfl). If the condition is true the handler catches the exception and contues with first contuation (VAR n). If the condition is false it contues with second contuation (raise e). The CPS semantic implements exception handlg by usg two primitives: gethdlr and sethdlr. The first primitive getdlr (variable h56), saves the current handler memory (at the of the expression it will be restored). Next, primitive sethdlr with variable n65 sets a new current handler (function n65). If the n by n raises an exception (like overflow), a jump to the current handler (function n65) is performed. The first struction to be executed function n65 is the restoration of the old current handler (sethdlr with variable h56). The rest of the code function n65 is the checkg of the raised exception agast exception overflow. At the of the function a jump to function k58 is made (this s the execution of the handler). On the other hand, if the multiplication does not raise an exception, the next primitive sethdlr with variable h56 restores the old current handler. Both cases (exception thrown or not), jumpg to function k58, which turn jumps to the exit of the program: function r The translator to CPS The translation from a lambda expression to a correspondg CPS expression is made by a recursive traversal of the lambda expression. We shown last examples, that each lambda expression is represented a hierarchical structure (a syntax tree) where each node represents an operation, and the children of a node represent the argument of the operation. Algorithm to translate lambda expressions to CPS expression Our new approach is a modification to the mutually-recursive function f of Appel [1]. We modified the translation by addg a new contuation for abnormal computations. The new function convert takes three arguments: a lambda expression, a contuation function c for succeed computations, and a contuation function e for failed computations. This translation algorithm was presented [4] and a more detailed explanation can be found [3]. Next, we present some of the new transformed functions for handle, raise, fn, fix, and app lambda expressions. The compe code can be found [3]. convert(handle (A,FN(z,B)),c, e) = val H = newvar ("H") fun e' w = APP(VAR H,[w]) ([(H,[z],convert(B,c, e))], convert (A,c,e')) convert(raise E, c, e) = convert(e,e,e) convert(fn (v,e), c, e) =

4 val F = newvar ("F"); val k = newvar ("k"); val ak = newvar ("ak"); fun e' z = APP(VAR ak,[z]) ([(F,[v,k,ak],convert (E,(fn z=>app (VAR k,[z])), e'))],c(var F)) convert((hx,bx,e),c, e) = val w = newvar ("w") val ak = newvar ("ak") fun e'' w = APP(VAR ak,[w]) fun g(h1::h,fn(v,b)::b)= (h1,[v,w,ak], convert (B, fn z=> g(nil,nil) = nil APP(VAR w,[z]), e''))::g(h,b) (g(hx,bx),convert (E,c, e)) convert(app (F,E), c, e) = val r= newvar ("r"); val x= newvar ("x"); val e'= newvar ("e'"); val z= newvar ("z"); ([(r,[x],c(var x)), (e',[z],e(var z))], convert(f,(fn f2=>convert(e,(fn e2=>app(f2, [e2,var r,var e'])), e)), e)) 3. AN EXECUTABLE FRAMEWORK The semantic of CPS is described by Appel [1], where the author describes the meang of CPS expressions by usg denotational or contuation semantics. This semantics is defed as a functor SML. The functor takes a CPS structure, a datatype for the values allowed the semantics, and some data defitions as arguments. Then, a function evaluates a CPS expression, usg an empty environment and a store at the begng of the evaluation. We implemented this contuation semantic by defg some new functions, an itial environment, and a store. Also, we lked some other programs like the translator of lambda expressions, and altogether we created a framework or model of CPS translation and terpretation (see figure 2). LAMBDA CODE STORE AND ENVIRONMENT Translator To CPS Evaluator Of CPS Translator to Flat CPS and Abstract mache code (optional) RESULT RESULT Figure 2. Model of CPS translation and terpretation The framework focuses on the experience of learng the CPS concepts by usg an environment of CPS programmg. It can serve as an aid gag a coherent understandg of the CPS programmg. The most important element of this framework is that programs lambda and CPS code can be directly compiled and executed and, the programmer can see how this source code (lambda) is transformed to correspondent CPS code together with important components of the framework, like an environment and a store. From this framework the user should be able to write their own programs, test them with different data, make experiments, etc. Research based upon the experiment approach can be conducted order to study the different structures to use a program, and so to determe what the best approach is. 3.1 Evaluator of CPS The evaluator of CPS is a program which takes a CPS program, an put, and performs an evaluation or execution of the CPS program, givg as a result a denotable value (which is later converted to a strg). The put is formed by two components: An environment. This is a function that maps CPS variables to denotable values (result values). The itial environment of the evaluator is created by three functions: val env0 = fn v=>raise Undefed (v) val env1 = bd(env0,"k", FUNC ic) val env2 = bd (env1, "ovfl", overflow_exn) The first value bound to the environment is the empty environment (raise Undefed); the second value is the itial contuation (identity contuation); and the third value is a predefed exception (overflow). A store. A function that maps locations (addresses) to denotable values. The itial store of the evaluator are three functions: val store0 = (100, fn l=>raise Exc_Overflow l,fn _=>0) val store1 = upd(store0,handler_ref,func default_handler) val store2 = upd(store1, overflow_loc, STRING "- overflow-")

5 Store0 establish that the first unused location is address 100. Addresses before 100 are used for keepg values like system exceptions. This store is the empty location (a raise to an exception); the second location has the itial default handler; and the third location has the predefed overflow exception handler. In next tables, we show the implementation and some comments of the evaluator of CPS. val overflow_loc = 7; val overflow_exn: dvalue = ARRAY [overflow_loc] The current handler is kept a special location store. We decided to store the address (reference) of the overflow exception the element 7 of a dvalue ARRAY. fun V env (INT i) = INT i V env (STRING s) = STRING s V env (VAR v) = env v Fun V converts CPS values to denotable values. For variables the function has to lock up the environment. fun bd (env:env, v:a.var, d) = fn w => if v=w then d else env w Function bd produces a new environment (a function of type a.var -> dvalue) by bdg a new variable with a denotable value. exception Undefed of var and Exc_Overflow of loc We defe two exceptions: Undefed that is used when a value is not the environment (undefed variable), and Exc_Overflow when a value is not the store. exception bad_equality and Error Two exceptions are defed: bad_equality, which is, raised when two non-compatible denotable values are compared and Error, which is raised when the result of the program is not a denotable value. fun evalprim (a.gethdlr, [], [c]) = (fn s => c [fetch s handler_ref] s) evalprim (sethdlr, [h], [c]) = (fn s => c [] (upd(s,handler_ref,h))) evalprim (+,[INT i, INT j],[c]) = overflow(fn ()=> (i + j),c) evalprim (<,[INT i, INT j],[t,f]) = if i<j then t[] else f[] evalprim (equal,[array [i],array [j]], [t,f]) = if i=j then t[] else f[] evalprim (makeref,[v],[c])= (fn (l,f,r)=>c [ARRAY [l]] (upd ((nextloc l,f,r),l,v))) evalprim (equal, [_,_], [t,f]) = raise bad_equality Function evalprim evaluates a primitive operator () applied to arguments. The first two primitive operators: gethdlr and sethdlr are used for exception handlg. A gethdlr operator fetches the current exception handler (handler_ref) from the store. A sethdlr operator sets (updates) a new current handler the store. Primitive makeref is important when an exception is declared. The operator serts the denotable value v the first available location the store. type env = a.var -> dvalue The type of the environment is a function from a variable (strg) to a denotable value. fun E (a.app(f,vl)) env = val FUNC g = V env f g (map (V env) vl) Function E is the function, which takes the whole CPS expression, an environment, and a store, and then evaluates the expression givg as a result a value of type answer (a strg). E (a.(p,vl,wl,el)) env = evalprim(p, map (V env) vl, map (fn e => fn al => E e (bdn(env,wl,al))) el ) In order to evaluate a primitive operator, we first convert the arguments usg the current environment (map (V env) vl). Then the contuation (a function) of the evalprim function is built by usg the contuation of this function (E), and a new environment with the addition of element wl. E (a.(fl,e)) env = fun h r1 (f,vl,b) = FUNC(fn al => E b (bdn(g r1,vl,al))) and g r = bdn(r, map #1 fl, map (h r) fl) E e (g env) Function E with a mutually recursive function (fl,e) evaluates expression e the augmented environment g. The augmented environment is built by bdg the list of recursive function names (map #1 fl), with the list of bodies (map (h r) fl) of each of these recursive functions (FUNC(fn al => E b (bdn(g r1,vl,al)))), and usg theirs respective local variables (bdn(g r1,vl,al)). fun ic [INT i] _ = Int.toStrg i ic [STRING s] _ = s ic [FUNC _] _ = "fn" ic [ARRAY [l]] _= "ref "^(Int.toStrg l) ic = raise Error

6 Function ic is used to produce answer (an strg) as a result of the evaluation. The function just transforms a denotable value to a strg. fun default_handler [ARRAY [l]] s = val STRING e =fetch s l "EXCEPTION "^e default_handler [_,ARRAY [l]] s = val STRING e =fetch s l "EXCEPTION "^e This function allows the program to display the output EXCEPTION name_exception whenever a user defed exception is raised. Remember that the name of the exception (strg) is saved memory, matag the location l a denotable value of type ARRAY. So, usg l as the location and the fetch function we can access the name of the raised exception. val env0 = fn v=>raise Undefed (v) val env1 = bd(env0,"k", FUNC ic) val env2 = bd (env1, "ovfl", overflow_exn); val store0 = (100, fn l=>raise Exc_Overflow l,fn _=>0) val store1 = upd(store0,handler_ref,func default_handler) val store2 = upd(store1, overflow_loc, STRING "-overflow-") We itialize the environment with three new bdgs (fn v=>raise Undefed (v), FUNC ic, and overflow_exn), and the store with three new store locations (fn l=>raise Exc_Overflow, FUNC default_handler, STRING "-overflow-"), where the last one is the handler for the overflow exception. 4. CONCLUSIONS Although some compilers like SML/NJ provide a way to see the CPS termediate representation, the format of that representation is too complex to be understood by a regular user or programmer. Our implementation is very simple to read and understand and can be used not only as a tool to learn the concept of CPS but also as a program to make experiments with lambda and CPS programmg. 5. REFERENCES [1] Andrew W. Appel. Compilg with Contuations. Cambridge University Press, Cambridge, England, [2] Andrew Appel and David B. MacQueen. A standard ML compiler. In Gilles Kahn, editor, Functional Programmg Languages and Computer Architecture, pages Sprger-Verlag, Berl, Lecture Notes Computer Science 274; Proceedgs of Conference held at Portland, Oregon. [3] Ramon Zatara. Design and Implementation of Exception Handlg with Zero Overhead Functional Languages. PhD Dissertation, Florida Institute of Technology, [4] Ramon Zatara and Ryan Stansifer. Exception Handlg for CPS Compilers. Proceedgs of the 41 st ACM Southeast Regional Conference (ACMSE 03), Savannah, Georgia. [5] Rob Milner, Mads Tofte, and Robert William Harper, Jr. The Defition of Standard ML. MIT Press, Cambridge, Massachussetts, [6] Shao, Z. Compilg Standard ML for Efficient Execution on Modern Maches. PhD Dissertation, Prceton university, fun eval (vl,e) dl = E e env2 store2 Fally, function eval will take a CPS expression e, with two lists of variables and denotable values (vl and dl), and then will call function E passg out formal parameters e, env2, and store2.

Design and Implementation of Exception Handling with Zero Overhead in Functional Languages. Ramon Zatarain Cabada

Design and Implementation of Exception Handling with Zero Overhead in Functional Languages By Ramon Zatarain Cabada A dissertation submitted to the College of Engineering at Florida Institute of Technology