Mercurial > urweb
view src/especialize.sml @ 1931:1a04b1edded2
Fix regression in http.c for long-polling connections; add lazy initialization of database connections, to avoid the overhead in handlers that don't use SQL
author | Adam Chlipala <adam@chlipala.net> |
---|---|
date | Wed, 11 Dec 2013 14:57:54 -0500 |
parents | 32784d27b5bc |
children |
line wrap: on
line source
(* Copyright (c) 2008-2013, Adam Chlipala * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - The names of contributors may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *) structure ESpecialize :> ESPECIALIZE = struct open Core structure E = CoreEnv structure U = CoreUtil type skey = exp structure K = struct type ord_key = con list * exp list fun compare ((cs1, es1), (cs2, es2)) = Order.join (Order.joinL U.Con.compare (cs1, cs2), fn () => Order.joinL U.Exp.compare (es1, es2)) end structure KM = BinaryMapFn(K) structure IM = IntBinaryMap structure IS = IntBinarySet val freeVars = U.Exp.foldB {kind = fn (_, _, xs) => xs, con = fn (_, _, xs) => xs, exp = fn (bound, e, xs) => case e of ERel x => if x >= bound then IS.add (xs, x - bound) else xs | _ => xs, bind = fn (bound, b) => case b of U.Exp.RelE _ => bound + 1 | _ => bound} 0 IS.empty fun isPolyT (t, _) = case t of TFun (_, ran) => isPolyT ran | TCFun _ => true | TKFun _ => true | _ => false fun isPoly (d, _) = case d of DVal (_, _, t, _, _) => isPolyT t | DValRec vis => List.exists (isPolyT o #3) vis | _ => false fun positionOf (v : int, ls) = let fun pof (pos, ls) = case ls of [] => raise Fail "Defunc.positionOf" | v' :: ls' => if v = v' then pos else pof (pos + 1, ls') in pof (0, ls) end fun squish fvs = U.Exp.mapB {kind = fn _ => fn k => k, con = fn _ => fn c => c, exp = fn bound => fn e => case e of ERel x => if x >= bound then ERel (positionOf (x - bound, fvs) + bound) else e | _ => e, bind = fn (bound, b) => case b of U.Exp.RelE _ => bound + 1 | _ => bound} 0 type func = { name : string, args : int KM.map, body : exp, typ : con, tag : string, constArgs : int (* What length prefix of the arguments never vary across recursive calls? *) } type state = { maxName : int, funcs : func IM.map, decls : (string * int * con * exp * string) list, specialized : IS.set } fun default (_, x, st) = (x, st) fun functionInside known = U.Con.exists {kind = fn _ => false, con = fn TFun _ => true | TCFun _ => true | CFfi ("Basis", "transaction") => true | CFfi ("Basis", "eq") => true | CFfi ("Basis", "num") => true | CFfi ("Basis", "ord") => true | CFfi ("Basis", "show") => true | CFfi ("Basis", "read") => true | CFfi ("Basis", "sql_injectable_prim") => true | CFfi ("Basis", "sql_injectable") => true | CNamed n => IS.member (known, n) | _ => false} fun getApp (e, _) = case e of ENamed f => SOME (f, []) | EApp (e1, e2) => (case getApp e1 of NONE => NONE | SOME (f, xs) => SOME (f, xs @ [e2])) | _ => NONE val getApp = fn e => case getApp e of v as SOME (_, _ :: _) => v | _ => NONE val maxInt = Option.getOpt (Int.maxInt, 9999) fun calcConstArgs enclosingFunctions e = let fun ca depth e = case #1 e of EPrim _ => maxInt | ERel _ => maxInt | ENamed n => if IS.member (enclosingFunctions, n) then 0 else maxInt | ECon (_, _, _, NONE) => maxInt | ECon (_, _, _, SOME e) => ca depth e | EFfi _ => maxInt | EFfiApp (_, _, ecs) => foldl (fn ((e, _), d) => Int.min (ca depth e, d)) maxInt ecs | EApp (e1, e2) => let fun default () = Int.min (ca depth e1, ca depth e2) in case getApp e of NONE => default () | SOME (f, args) => if not (IS.member (enclosingFunctions, f)) then default () else let fun visitArgs (count, args) = case args of [] => count | arg :: args' => let fun default () = foldl (fn (e, d) => Int.min (ca depth e, d)) count args in case #1 arg of ERel n => if n = depth - 1 - count then visitArgs (count + 1, args') else default () | _ => default () end in visitArgs (0, args) end end | EAbs (_, _, _, e1) => ca (depth + 1) e1 | ECApp (e1, _) => ca depth e1 | ECAbs (_, _, e1) => ca depth e1 | EKAbs (_, e1) => ca depth e1 | EKApp (e1, _) => ca depth e1 | ERecord xets => foldl (fn ((_, e, _), d) => Int.min (ca depth e, d)) maxInt xets | EField (e1, _, _) => ca depth e1 | EConcat (e1, _, e2, _) => Int.min (ca depth e1, ca depth e2) | ECut (e1, _, _) => ca depth e1 | ECutMulti (e1, _, _) => ca depth e1 | ECase (e1, pes, _) => foldl (fn ((p, e), d) => Int.min (ca (depth + E.patBindsN p) e, d)) (ca depth e1) pes | EWrite e1 => ca depth e1 | EClosure (_, es) => foldl (fn (e, d) => Int.min (ca depth e, d)) maxInt es | ELet (_, _, e1, e2) => Int.min (ca depth e1, ca (depth + 1) e2) | EServerCall (_, es, _, _) => foldl (fn (e, d) => Int.min (ca depth e, d)) maxInt es fun enterAbs depth e = case #1 e of EAbs (_, _, _, e1) => enterAbs (depth + 1) e1 | _ => ca depth e in enterAbs 0 e end fun optionExists p opt = case opt of NONE => false | SOME v => p v fun specialize' (funcs, specialized) file = let val known = foldl (fn (d, known) => case #1 d of DCon (_, n, _, c) => if functionInside known c then IS.add (known, n) else known | DDatatype dts => if List.exists (List.exists (optionExists (functionInside known) o #3) o #4) dts then foldl (fn (dt, known) => IS.add (known, #2 dt)) known dts else known | _ => known) IS.empty file fun bind (env, b) = case b of U.Decl.RelE xt => xt :: env | _ => env fun exp (env, e as (_, loc), st : state) = let (*val () = Print.prefaces "exp" [("e", CorePrint.p_exp CoreEnv.empty (e, ErrorMsg.dummySpan))]*) fun default () = case #1 e of EPrim _ => (e, st) | ERel _ => (e, st) | ENamed _ => (e, st) | ECon (_, _, _, NONE) => (e, st) | ECon (dk, pc, cs, SOME e) => let val (e, st) = exp (env, e, st) in ((ECon (dk, pc, cs, SOME e), loc), st) end | EFfi _ => (e, st) | EFfiApp (m, x, es) => let val (es, st) = ListUtil.foldlMap (fn ((e, t), st) => let val (e, st) = exp (env, e, st) in ((e, t), st) end) st es in ((EFfiApp (m, x, es), loc), st) end | EApp (e1, e2) => let val (e1, st) = exp (env, e1, st) val (e2, st) = exp (env, e2, st) in ((EApp (e1, e2), loc), st) end | EAbs (x, d, r, e) => let val (e, st) = exp ((x, d) :: env, e, st) in ((EAbs (x, d, r, e), loc), st) end | ECApp (e, c) => let val (e, st) = exp (env, e, st) in ((ECApp (e, c), loc), st) end | ECAbs _ => (e, st) | EKAbs _ => (e, st) | EKApp (e, k) => let val (e, st) = exp (env, e, st) in ((EKApp (e, k), loc), st) end | ERecord fs => let val (fs, st) = ListUtil.foldlMap (fn ((c1, e, c2), st) => let val (e, st) = exp (env, e, st) in ((c1, e, c2), st) end) st fs in ((ERecord fs, loc), st) end | EField (e, c, cs) => let val (e, st) = exp (env, e, st) in ((EField (e, c, cs), loc), st) end | EConcat (e1, c1, e2, c2) => let val (e1, st) = exp (env, e1, st) val (e2, st) = exp (env, e2, st) in ((EConcat (e1, c1, e2, c2), loc), st) end | ECut (e, c, cs) => let val (e, st) = exp (env, e, st) in ((ECut (e, c, cs), loc), st) end | ECutMulti (e, c, cs) => let val (e, st) = exp (env, e, st) in ((ECutMulti (e, c, cs), loc), st) end | ECase (e, pes, cs) => let val (e, st) = exp (env, e, st) val (pes, st) = ListUtil.foldlMap (fn ((p, e), st) => let val (e, st) = exp (E.patBindsL p @ env, e, st) in ((p, e), st) end) st pes in ((ECase (e, pes, cs), loc), st) end | EWrite e => let val (e, st) = exp (env, e, st) in ((EWrite e, loc), st) end | EClosure (n, es) => let val (es, st) = ListUtil.foldlMap (fn (e, st) => exp (env, e, st)) st es in ((EClosure (n, es), loc), st) end | ELet (x, t, e1, e2) => let val (e1, st) = exp (env, e1, st) val (e2, st) = exp ((x, t) :: env, e2, st) in ((ELet (x, t, e1, e2), loc), st) end | EServerCall (n, es, t, fm) => let val (es, st) = ListUtil.foldlMap (fn (e, st) => exp (env, e, st)) st es in ((EServerCall (n, es, t, fm), loc), st) end in case getApp e of NONE => default () | SOME (f, xs) => case IM.find (#funcs st, f) of NONE => ((*print ("No find: " ^ Int.toString f ^ "\n");*) default ()) | SOME {name, args, body, typ, tag, constArgs} => let val (xs, st) = ListUtil.foldlMap (fn (e, st) => exp (env, e, st)) st xs (*val () = Print.prefaces "Consider" [("e", CorePrint.p_exp CoreEnv.empty e)]*) val loc = ErrorMsg.dummySpan val oldXs = xs fun findSplit av (initialPart, constArgs, xs, typ, fxs, fvs) = let fun default () = if initialPart then ([], oldXs, IS.empty) else (rev fxs, xs, fvs) in case (#1 typ, xs) of (TFun (dom, ran), e :: xs') => if constArgs > 0 then let val fi = functionInside known dom in if initialPart orelse fi then findSplit av (not fi andalso initialPart, constArgs - 1, xs', ran, e :: fxs, IS.union (fvs, freeVars e)) else default () end else default () | _ => default () end val (fxs, xs, fvs) = findSplit true (true, constArgs, xs, typ, [], IS.empty) val vts = map (fn n => #2 (List.nth (env, n))) (IS.listItems fvs) val fxs' = map (squish (IS.listItems fvs)) fxs val p_bool = Print.PD.string o Bool.toString in (*Print.prefaces "Func" [("name", Print.PD.string name), ("e", CorePrint.p_exp CoreEnv.empty e), ("fxs'", Print.p_list (CorePrint.p_exp CoreEnv.empty) fxs')];*) if List.all (fn (ERel _, _) => true | _ => false) fxs' then default () else case KM.find (args, (vts, fxs')) of SOME f' => let val e = (ENamed f', loc) val e = IS.foldr (fn (arg, e) => (EApp (e, (ERel arg, loc)), loc)) e fvs val e = foldl (fn (arg, e) => (EApp (e, arg), loc)) e xs in (*Print.prefaces "Brand new (reuse)" [("e'", CorePrint.p_exp CoreEnv.empty e)];*) (e, st) end | NONE => let (*val () = Print.prefaces "New one" [("name", Print.PD.string name), ("f", Print.PD.string (Int.toString f)), ("|fvs|", Print.PD.string (Int.toString (IS.numItems fvs))), ("|fxs|", Print.PD.string (Int.toString (length fxs))), ("fxs'", Print.p_list (CorePrint.p_exp CoreEnv.empty) fxs'), ("spec", Print.PD.string (Bool.toString (IS.member (#specialized st, f))))]*) (*val () = Print.prefaces ("Yes(" ^ name ^ ")") [("fxs'", Print.p_list (CorePrint.p_exp CoreEnv.empty) fxs')]*) (*val () = Print.prefaces name [("Available", Print.PD.string (Int.toString constArgs)), ("Used", Print.PD.string (Int.toString (length fxs'))), ("fxs'", Print.p_list (CorePrint.p_exp CoreEnv.empty) fxs')]*) fun subBody (body, typ, fxs') = case (#1 body, #1 typ, fxs') of (_, _, []) => SOME (body, typ) | (EAbs (_, _, _, body'), TFun (_, typ'), x :: fxs'') => let val body'' = E.subExpInExp (0, x) body' in subBody (body'', typ', fxs'') end | _ => NONE in case subBody (body, typ, fxs') of NONE => default () | SOME (body', typ') => let val f' = #maxName st val args = KM.insert (args, (vts, fxs'), f') val funcs = IM.insert (#funcs st, f, {name = name, args = args, body = body, typ = typ, tag = tag, constArgs = calcConstArgs (IS.singleton f) body}) val st = { maxName = f' + 1, funcs = funcs, decls = #decls st, specialized = IS.add (#specialized st, f') } (*val () = Print.prefaces "specExp" [("f", CorePrint.p_exp env (ENamed f, loc)), ("f'", CorePrint.p_exp env (ENamed f', loc)), ("xs", Print.p_list (CorePrint.p_exp env) xs), ("fxs'", Print.p_list (CorePrint.p_exp E.empty) fxs'), ("e", CorePrint.p_exp env (e, loc))]*) val (body', typ') = IS.foldl (fn (n, (body', typ')) => let val (x, xt) = List.nth (env, n) in ((EAbs (x, xt, typ', body'), loc), (TFun (xt, typ'), loc)) end) (body', typ') fvs (*val () = print ("NEW: " ^ name ^ "__" ^ Int.toString f' ^ "\n")*) val body' = ReduceLocal.reduceExp body' (*val () = Print.preface ("PRE", CorePrint.p_exp CoreEnv.empty body')*) val (body', st) = exp (env, body', st) val e' = (ENamed f', loc) val e' = IS.foldr (fn (arg, e) => (EApp (e, (ERel arg, loc)), loc)) e' fvs val e' = foldl (fn (arg, e) => (EApp (e, arg), loc)) e' xs (*val () = Print.prefaces "Brand new" [("e'", CorePrint.p_exp CoreEnv.empty e'), ("e", CorePrint.p_exp CoreEnv.empty e), ("body'", CorePrint.p_exp CoreEnv.empty body')]*) in (e', {maxName = #maxName st, funcs = #funcs st, decls = (name, f', typ', body', tag) :: #decls st, specialized = #specialized st}) end end end end fun doDecl (d, (st : state, changed)) = let (*val befor = Time.now ()*) val funcs = #funcs st val funcs = case #1 d of DValRec vis => let val fs = foldl (fn ((_, n, _, _, _), fs) => IS.add (fs, n)) IS.empty vis val constArgs = foldl (fn ((_, _, _, e, _), constArgs) => Int.min (constArgs, calcConstArgs fs e)) maxInt vis in (*Print.prefaces "ConstArgs" [("d", CorePrint.p_decl CoreEnv.empty d), ("ca", Print.PD.string (Int.toString constArgs))];*) foldl (fn ((x, n, c, e, tag), funcs) => IM.insert (funcs, n, {name = x, args = KM.empty, body = e, typ = c, tag = tag, constArgs = constArgs})) funcs vis end | _ => funcs val st = {maxName = #maxName st, funcs = funcs, decls = [], specialized = #specialized st} (*val () = Print.prefaces "decl" [("d", CorePrint.p_decl CoreEnv.empty d)]*) val (d', st) = if isPoly d then (d, st) else case #1 d of DVal (x, n, t, e, s) => let (*val () = Print.preface ("Visiting", Print.box [Print.PD.string (x ^ "__" ^ Int.toString n), Print.space, Print.PD.string ":", Print.space, CorePrint.p_con CoreEnv.empty t])*) val (e, st) = exp ([], e, st) in ((DVal (x, n, t, e, s), #2 d), st) end | DValRec vis => let (*val () = Print.preface ("Visiting", Print.p_list (fn vi => Print.box [Print.PD.string (#1 vi ^ "__" ^ Int.toString (#2 vi)), Print.space, Print.PD.string ":", Print.space, CorePrint.p_con CoreEnv.empty (#3 vi)]) vis)*) val (vis, st) = ListUtil.foldlMap (fn ((x, n, t, e, s), st) => let val (e, st) = exp ([], e, st) in ((x, n, t, e, s), st) end) st vis in ((DValRec vis, #2 d), st) end | DTable (s, n, t, s1, e1, t1, e2, t2) => let val (e1, st) = exp ([], e1, st) val (e2, st) = exp ([], e2, st) in ((DTable (s, n, t, s1, e1, t2, e2, t2), #2 d), st) end | DView (x, n, s, e, t) => let val (e, st) = exp ([], e, st) in ((DView (x, n, s, e, t), #2 d), st) end | DTask (e1, e2) => let val (e1, st) = exp ([], e1, st) val (e2, st) = exp ([], e2, st) in ((DTask (e1, e2), #2 d), st) end | _ => (d, st) (*val () = print "/decl\n"*) val funcs = #funcs st val funcs = case #1 d of DVal (x, n, c, e as (EAbs _, _), tag) => ((*Print.prefaces "ConstArgs[2]" [("d", CorePrint.p_decl CoreEnv.empty d), ("ca", Print.PD.string (Int.toString (calcConstArgs (IS.singleton n) e)))];*) IM.insert (funcs, n, {name = x, args = KM.empty, body = e, typ = c, tag = tag, constArgs = calcConstArgs (IS.singleton n) e})) | DVal (_, n, _, (ENamed n', _), _) => (case IM.find (funcs, n') of NONE => funcs | SOME v => IM.insert (funcs, n, v)) | _ => funcs val (changed, ds) = case #decls st of [] => (changed, [d']) | vis => (true, case d' of (DValRec vis', _) => [(DValRec (vis @ vis'), ErrorMsg.dummySpan)] | _ => [(DValRec vis, ErrorMsg.dummySpan), d']) in (*Print.prefaces "doDecl" [("d", CorePrint.p_decl E.empty d), ("d'", CorePrint.p_decl E.empty d')];*) (ds, ({maxName = #maxName st, funcs = funcs, decls = [], specialized = #specialized st}, changed)) end (*val () = Print.preface ("RESET", CorePrint.p_file CoreEnv.empty file)*) val (ds, (st, changed)) = ListUtil.foldlMapConcat doDecl ({maxName = U.File.maxName file + 1, funcs = funcs, decls = [], specialized = specialized}, false) file in (*print ("Changed = " ^ Bool.toString changed ^ "\n");*) (changed, ds, #funcs st, #specialized st) end fun specializeL (funcs, specialized) file = let val file = ReduceLocal.reduce file (*val file = ReduceLocal.reduce file*) val (changed, file, funcs, specialized) = specialize' (funcs, specialized) file (*val file = ReduceLocal.reduce file val file = CoreUntangle.untangle file val file = Shake.shake file*) in (*print "Round over\n";*) if changed then let (*val file = ReduceLocal.reduce file*) (*val () = Print.prefaces "Pre-untangle" [("file", CorePrint.p_file CoreEnv.empty file)]*) val file = CoreUntangle.untangle file (*val () = Print.prefaces "Post-untangle" [("file", CorePrint.p_file CoreEnv.empty file)]*) val file = Shake.shake file in (*print "Again!\n";*) (*Print.prefaces "Again" [("file", CorePrint.p_file CoreEnv.empty file)];*) specializeL (funcs, specialized) file end else file end val specialize = specializeL (IM.empty, IS.empty) end