X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fvectorise%2FVectorise.hs;h=aad5144b6bc824db51966add25887d70cdb406ff;hb=671f6c78fd7b9b6453b4386e5dc64f169f7ed291;hp=a4da8584f501cb7ead9c277106b59f42261f6d1c;hpb=8776493a75bc44c37cddebfef778356d17d81bd6;p=ghc-hetmet.git diff --git a/compiler/vectorise/Vectorise.hs b/compiler/vectorise/Vectorise.hs index a4da858..aad5144 100644 --- a/compiler/vectorise/Vectorise.hs +++ b/compiler/vectorise/Vectorise.hs @@ -1,416 +1,620 @@ +{-# OPTIONS -fno-warn-missing-signatures #-} + module Vectorise( vectorise ) where -#include "HsVersions.h" - import VectMonad import VectUtils +import VectVar +import VectType +import Vectorise.Vect +import Vectorise.Env -import DynFlags -import HscTypes +import HscTypes hiding ( MonadThings(..) ) -import CoreLint ( showPass, endPass ) +import Module ( PackageId ) import CoreSyn import CoreUtils +import CoreUnfold ( mkInlineRule ) +import MkCore ( mkWildCase ) import CoreFVs +import CoreMonad ( CoreM, getHscEnv ) import DataCon import TyCon import Type -import TypeRep +import FamInstEnv ( extendFamInstEnvList ) import Var import VarEnv import VarSet -import Name ( mkSysTvName ) -import NameEnv import Id -import MkId ( unwrapFamInstScrut ) - -import DsMonad hiding (mapAndUnzipM) -import DsUtils ( mkCoreTup, mkCoreTupTy ) +import OccName +import BasicTypes ( isLoopBreaker ) -import PrelNames +import Literal import TysWiredIn -import BasicTypes ( Boxity(..) ) +import TysPrim ( intPrimTy ) import Outputable import FastString -import Control.Monad ( liftM, liftM2, mapAndUnzipM, zipWithM_ ) -import Data.Maybe ( maybeToList ) +import Util ( zipLazy ) +import Control.Monad +import Data.List ( sortBy, unzip4 ) -vectorise :: HscEnv -> ModGuts -> IO ModGuts -vectorise hsc_env guts - | not (Opt_Vectorise `dopt` dflags) = return guts - | otherwise - = do - showPass dflags "Vectorisation" + +debug = False +dtrace s x = if debug then pprTrace "Vectorise" s x else x + +-- | Vectorise a single module. +-- Takes the package containing the DPH backend we're using. Eg either dph-par or dph-seq. +vectorise :: PackageId -> ModGuts -> CoreM ModGuts +vectorise backend guts + = do hsc_env <- getHscEnv + liftIO $ vectoriseIO backend hsc_env guts + + +-- | Vectorise a single monad, given its HscEnv (code gen environment). +vectoriseIO :: PackageId -> HscEnv -> ModGuts -> IO ModGuts +vectoriseIO backend hsc_env guts + = do -- Get information about currently loaded external packages. eps <- hscEPS hsc_env + + -- Combine vectorisation info from the current module, and external ones. let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps - Just (info', guts') <- initV hsc_env guts info (vectModule guts) - endPass dflags "Vectorisation" Opt_D_dump_vect (mg_binds guts') - return $ guts' { mg_vect_info = info' } - where - dflags = hsc_dflags hsc_env -vectModule :: ModGuts -> VM ModGuts -vectModule guts = return guts + -- Run the main VM computation. + Just (info', guts') <- initV backend hsc_env guts info (vectModule guts) + return (guts' { mg_vect_info = info' }) --- ---------------------------------------------------------------------------- --- Bindings -vectBndr :: Var -> VM (Var, Var) -vectBndr v - = do - vty <- vectType (idType v) - lty <- mkPArrayType vty - let vv = v `Id.setIdType` vty - lv = v `Id.setIdType` lty - updLEnv (mapTo vv lv) - return (vv, lv) +-- | Vectorise a single module, in the VM monad. +vectModule :: ModGuts -> VM ModGuts +vectModule guts + = do -- Vectorise the type environment. + -- This may add new TyCons and DataCons. + -- TODO: What new binds do we get back here? + (types', fam_insts, tc_binds) <- vectTypeEnv (mg_types guts) + + -- TODO: What is this? + let fam_inst_env' = extendFamInstEnvList (mg_fam_inst_env guts) fam_insts + updGEnv (setFamInstEnv fam_inst_env') + + -- dicts <- mapM buildPADict pa_insts + -- workers <- mapM vectDataConWorkers pa_insts + + -- Vectorise all the top level bindings. + binds' <- mapM vectTopBind (mg_binds guts) + + return $ guts { mg_types = types' + , mg_binds = Rec tc_binds : binds' + , mg_fam_inst_env = fam_inst_env' + , mg_fam_insts = mg_fam_insts guts ++ fam_insts + } + + +-- | Try to vectorise a top-level binding. +-- If it doesn't vectorise then return it unharmed. +-- +-- For example, for the binding +-- +-- @ +-- foo :: Int -> Int +-- foo = \x -> x + x +-- @ +-- +-- we get +-- @ +-- foo :: Int -> Int +-- foo = \x -> vfoo $: x +-- +-- v_foo :: Closure void vfoo lfoo +-- v_foo = closure vfoo lfoo void +-- +-- vfoo :: Void -> Int -> Int +-- vfoo = ... +-- +-- lfoo :: PData Void -> PData Int -> PData Int +-- lfoo = ... +-- @ +-- +-- @vfoo@ is the "vectorised", or scalar, version that does the same as the original +-- function foo, but takes an explicit environment. +-- +-- @lfoo@ is the "lifted" version that works on arrays. +-- +-- @v_foo@ combines both of these into a `Closure` that also contains the +-- environment. +-- +-- The original binding @foo@ is rewritten to call the vectorised version +-- present in the closure. +-- +vectTopBind :: CoreBind -> VM CoreBind +vectTopBind b@(NonRec var expr) + = do + (inline, expr') <- vectTopRhs var expr + var' <- vectTopBinder var inline expr' + + -- Vectorising the body may create other top-level bindings. + hs <- takeHoisted + + -- To get the same functionality as the original body we project + -- out its vectorised version from the closure. + cexpr <- tryConvert var var' expr + + return . Rec $ (var, cexpr) : (var', expr') : hs + `orElseV` + return b + +vectTopBind b@(Rec bs) + = do + (vars', _, exprs') + <- fixV $ \ ~(_, inlines, rhss) -> + do vars' <- sequence [vectTopBinder var inline rhs + | (var, ~(inline, rhs)) <- zipLazy vars (zip inlines rhss)] + (inlines', exprs') + <- mapAndUnzipM (uncurry vectTopRhs) bs + + return (vars', inlines', exprs') + + hs <- takeHoisted + cexprs <- sequence $ zipWith3 tryConvert vars vars' exprs + return . Rec $ zip vars cexprs ++ zip vars' exprs' ++ hs + `orElseV` + return b where - mapTo vv lv env = env { local_vars = extendVarEnv (local_vars env) v (Var vv, Var lv) } - -vectBndrIn :: Var -> VM a -> VM (Var, Var, a) -vectBndrIn v p - = localV - $ do - (vv, lv) <- vectBndr v - x <- p - return (vv, lv, x) - -vectBndrsIn :: [Var] -> VM a -> VM ([Var], [Var], a) -vectBndrsIn vs p - = localV - $ do - (vvs, lvs) <- mapAndUnzipM vectBndr vs - x <- p - return (vvs, lvs, x) + (vars, exprs) = unzip bs + + +-- | Make the vectorised version of this top level binder, and add the mapping +-- between it and the original to the state. For some binder @foo@ the vectorised +-- version is @$v_foo@ +-- +-- NOTE: vectTopBinder *MUST* be lazy in inline and expr because of how it is +-- used inside of fixV in vectTopBind +vectTopBinder + :: Var -- ^ Name of the binding. + -> Inline -- ^ Whether it should be inlined, used to annotate it. + -> CoreExpr -- ^ RHS of the binding, used to set the `Unfolding` of the returned `Var`. + -> VM Var -- ^ Name of the vectorised binding. + +vectTopBinder var inline expr + = do + -- Vectorise the type attached to the var. + vty <- vectType (idType var) + + -- Make the vectorised version of binding's name, and set the unfolding used for inlining. + var' <- liftM (`setIdUnfolding` unfolding) + $ cloneId mkVectOcc var vty + + -- Add the mapping between the plain and vectorised name to the state. + defGlobalVar var var' + + return var' + where + unfolding = case inline of + Inline arity -> mkInlineRule expr (Just arity) + DontInline -> noUnfolding + + +-- | Vectorise the RHS of a top-level binding, in an empty local environment. +vectTopRhs + :: Var -- ^ Name of the binding. + -> CoreExpr -- ^ Body of the binding. + -> VM (Inline, CoreExpr) + +vectTopRhs var expr + = dtrace (vcat [text "vectTopRhs", ppr expr]) + $ closedV + $ do (inline, vexpr) <- inBind var + $ vectPolyExpr (isLoopBreaker $ idOccInfo var) + (freeVars expr) + return (inline, vectorised vexpr) + + +-- | Project out the vectorised version of a binding from some closure, +-- or return the original body if that doesn't work. +tryConvert + :: Var -- ^ Name of the original binding (eg @foo@) + -> Var -- ^ Name of vectorised version of binding (eg @$vfoo@) + -> CoreExpr -- ^ The original body of the binding. + -> VM CoreExpr + +tryConvert var vect_var rhs + = fromVect (idType var) (Var vect_var) `orElseV` return rhs + -- ---------------------------------------------------------------------------- -- Expressions -replicateP :: CoreExpr -> CoreExpr -> VM CoreExpr -replicateP expr len - = do - dict <- paDictOfType ty - rep <- builtin replicatePAVar - return $ mkApps (Var rep) [Type ty, dict, expr, len] - where - ty = exprType expr -capply :: (CoreExpr, CoreExpr) -> (CoreExpr, CoreExpr) -> VM (CoreExpr, CoreExpr) -capply (vfn, lfn) (varg, larg) - = do - apply <- builtin applyClosureVar - applyP <- builtin applyClosurePVar - return (mkApps (Var apply) [Type arg_ty, Type res_ty, vfn, varg], - mkApps (Var applyP) [Type arg_ty, Type res_ty, lfn, larg]) +-- | Vectorise a polymorphic expression +vectPolyExpr + :: Bool -- ^ When vectorising the RHS of a binding, whether that + -- binding is a loop breaker. + -> CoreExprWithFVs + -> VM (Inline, VExpr) + +vectPolyExpr loop_breaker (_, AnnNote note expr) + = do (inline, expr') <- vectPolyExpr loop_breaker expr + return (inline, vNote note expr') + +vectPolyExpr loop_breaker expr + = dtrace (vcat [text "vectPolyExpr", ppr (deAnnotate expr)]) + $ do + arity <- polyArity tvs + polyAbstract tvs $ \args -> + do + (inline, mono') <- vectFnExpr False loop_breaker mono + return (addInlineArity inline arity, + mapVect (mkLams $ tvs ++ args) mono') where - fn_ty = exprType vfn - (arg_ty, res_ty) = splitClosureTy fn_ty + (tvs, mono) = collectAnnTypeBinders expr -vectVar :: CoreExpr -> Var -> VM (CoreExpr, CoreExpr) -vectVar lc v - = do - r <- lookupVar v - case r of - Local es -> return es - Global vexpr -> do - lexpr <- replicateP vexpr lc - return (vexpr, lexpr) - -vectPolyVar :: CoreExpr -> Var -> [Type] -> VM (CoreExpr, CoreExpr) -vectPolyVar lc v tys - = do - r <- lookupVar v - case r of - Local (vexpr, lexpr) -> liftM2 (,) (mk_app vexpr) (mk_app lexpr) - Global poly -> do - vexpr <- mk_app poly - lexpr <- replicateP vexpr lc - return (vexpr, lexpr) + +-- | Vectorise a core expression. +vectExpr :: CoreExprWithFVs -> VM VExpr +vectExpr (_, AnnType ty) + = liftM vType (vectType ty) + +vectExpr (_, AnnVar v) + = vectVar v + +vectExpr (_, AnnLit lit) + = vectLiteral lit + +vectExpr (_, AnnNote note expr) + = liftM (vNote note) (vectExpr expr) + +vectExpr e@(_, AnnApp _ arg) + | isAnnTypeArg arg + = vectTyAppExpr fn tys where - mk_app e = applyToTypes e =<< mapM vectType tys + (fn, tys) = collectAnnTypeArgs e -abstractOverTyVars :: [TyVar] -> ((CoreExpr -> CoreExpr) -> VM a) -> VM a -abstractOverTyVars tvs p +vectExpr (_, AnnApp (_, AnnVar v) (_, AnnLit lit)) + | Just con <- isDataConId_maybe v + , is_special_con con = do - mdicts <- mapM mk_dict_var tvs - zipWithM_ (\tv -> maybe (deleteTyVarPA tv) (extendTyVarPA tv . Var)) tvs mdicts - p (mk_lams mdicts) + let vexpr = App (Var v) (Lit lit) + lexpr <- liftPD vexpr + return (vexpr, lexpr) where - mk_dict_var tv = do - r <- paDictArgType tv - case r of - Just ty -> liftM Just (newLocalVar FSLIT("dPA") ty) - Nothing -> return Nothing + is_special_con con = con `elem` [intDataCon, floatDataCon, doubleDataCon] - mk_lams mdicts = mkLams [arg | (tv, mdict) <- zip tvs mdicts - , arg <- tv : maybeToList mdict] -applyToTypes :: CoreExpr -> [Type] -> VM CoreExpr -applyToTypes expr tys - = do - dicts <- mapM paDictOfType tys - return $ mkApps expr [arg | (ty, dict) <- zip tys dicts - , arg <- [Type ty, dict]] - - -vectPolyExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr) -vectPolyExpr lc expr - = localV - . abstractOverTyVars tvs $ \mk_lams -> - -- FIXME: shadowing (tvs in lc) - do - (vmono, lmono) <- vectExpr lc mono - return $ (mk_lams vmono, mk_lams lmono) - where - (tvs, mono) = collectAnnTypeBinders expr - -vectExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr) -vectExpr lc (_, AnnType ty) - = do - vty <- vectType ty - return (Type vty, Type vty) +-- TODO: Avoid using closure application for dictionaries. +-- vectExpr (_, AnnApp fn arg) +-- | if is application of dictionary +-- just use regular app instead of closure app. -vectExpr lc (_, AnnVar v) = vectVar lc v +-- for lifted version. +-- do liftPD (sub a dNumber) +-- lift the result of the selection, not sub and dNumber seprately. -vectExpr lc (_, AnnLit lit) - = do - let vexpr = Lit lit - lexpr <- replicateP vexpr lc - return (vexpr, lexpr) +vectExpr (_, AnnApp fn arg) + = dtrace (text "AnnApp" <+> ppr (deAnnotate fn) <+> ppr (deAnnotate arg)) + $ do + arg_ty' <- vectType arg_ty + res_ty' <- vectType res_ty -vectExpr lc (_, AnnNote note expr) - = do - (vexpr, lexpr) <- vectExpr lc expr - return (Note note vexpr, Note note lexpr) + dtrace (text "vectorising fn " <> ppr (deAnnotate fn)) $ return () + fn' <- vectExpr fn + dtrace (text "fn' = " <> ppr fn') $ return () -vectExpr lc e@(_, AnnApp _ arg) - | isAnnTypeArg arg - = vectTyAppExpr lc fn tys - where - (fn, tys) = collectAnnTypeArgs e + arg' <- vectExpr arg -vectExpr lc (_, AnnApp fn arg) - = do - fn' <- vectExpr lc fn - arg' <- vectExpr lc arg - capply fn' arg' + mkClosureApp arg_ty' res_ty' fn' arg' + where + (arg_ty, res_ty) = splitFunTy . exprType $ deAnnotate fn -vectExpr lc (_, AnnCase expr bndr ty alts) - = panic "vectExpr: case" +vectExpr (_, AnnCase scrut bndr ty alts) + | Just (tycon, ty_args) <- splitTyConApp_maybe scrut_ty + , isAlgTyCon tycon + = vectAlgCase tycon ty_args scrut bndr ty alts + where + scrut_ty = exprType (deAnnotate scrut) -vectExpr lc (_, AnnLet (AnnNonRec bndr rhs) body) +vectExpr (_, AnnLet (AnnNonRec bndr rhs) body) = do - (vrhs, lrhs) <- vectPolyExpr lc rhs - (vbndr, lbndr, (vbody, lbody)) <- vectBndrIn bndr (vectExpr lc body) - return (Let (NonRec vbndr vrhs) vbody, - Let (NonRec lbndr lrhs) lbody) + vrhs <- localV . inBind bndr . liftM snd $ vectPolyExpr False rhs + (vbndr, vbody) <- vectBndrIn bndr (vectExpr body) + return $ vLet (vNonRec vbndr vrhs) vbody -vectExpr lc (_, AnnLet (AnnRec prs) body) +vectExpr (_, AnnLet (AnnRec bs) body) = do - (vbndrs, lbndrs, (vrhss, vbody, lrhss, lbody)) <- vectBndrsIn bndrs vect - return (Let (Rec (zip vbndrs vrhss)) vbody, - Let (Rec (zip lbndrs lrhss)) lbody) + (vbndrs, (vrhss, vbody)) <- vectBndrsIn bndrs + $ liftM2 (,) + (zipWithM vect_rhs bndrs rhss) + (vectExpr body) + return $ vLet (vRec vbndrs vrhss) vbody + where + (bndrs, rhss) = unzip bs + + vect_rhs bndr rhs = localV + . inBind bndr + . liftM snd + $ vectPolyExpr (isLoopBreaker $ idOccInfo bndr) rhs + +vectExpr e@(_, AnnLam bndr _) + | isId bndr = liftM snd $ vectFnExpr True False e +{- +onlyIfV (isEmptyVarSet fvs) (vectScalarLam bs $ deAnnotate body) + `orElseV` vectLam True fvs bs body where - (bndrs, rhss) = unzip prs - - vect = do - (vrhss, lrhss) <- mapAndUnzipM (vectExpr lc) rhss - (vbody, lbody) <- vectPolyExpr lc body - return (vrhss, vbody, lrhss, lbody) + (bs,body) = collectAnnValBinders e +-} -vectExpr lc e@(_, AnnLam bndr body) - | isTyVar bndr = pprPanic "vectExpr" (ppr $ deAnnotate e) +vectExpr e = cantVectorise "Can't vectorise expression" (ppr $ deAnnotate e) -vectExpr lc (fvs, AnnLam bndr body) - = do - let tyvars = filter isTyVar (varSetElems fvs) - info <- mkCEnvInfo fvs bndr body - (poly_vfn, poly_lfn) <- mkClosureFns info tyvars bndr body - vfn_var <- hoistExpr FSLIT("vfn") poly_vfn - lfn_var <- hoistExpr FSLIT("lfn") poly_lfn +-- | Vectorise an expression with an outer lambda abstraction. +vectFnExpr + :: Bool -- ^ When the RHS of a binding, whether that binding should be inlined. + -> Bool -- ^ Whether the binding is a loop breaker. + -> CoreExprWithFVs -- ^ Expression to vectorise. Must have an outer `AnnLam`. + -> VM (Inline, VExpr) - let (venv, lenv) = mkClosureEnvs info lc +vectFnExpr inline loop_breaker e@(fvs, AnnLam bndr _) + | isId bndr = onlyIfV (isEmptyVarSet fvs) + (mark DontInline . vectScalarLam bs $ deAnnotate body) + `orElseV` mark inlineMe (vectLam inline loop_breaker fvs bs body) + where + (bs,body) = collectAnnValBinders e + +vectFnExpr _ _ e = mark DontInline $ vectExpr e + +mark :: Inline -> VM a -> VM (Inline, a) +mark b p = do { x <- p; return (b,x) } + + +-- | Vectorise a function where are the args have scalar type, that is Int, Float or Double. +vectScalarLam + :: [Var] -- ^ Bound variables of function. + -> CoreExpr -- ^ Function body. + -> VM VExpr +vectScalarLam args body + = dtrace (vcat [text "vectScalarLam ", ppr args, ppr body]) + $ do scalars <- globalScalars + onlyIfV (all is_scalar_ty arg_tys + && is_scalar_ty res_ty + && is_scalar (extendVarSetList scalars args) body + && uses scalars body) + $ do + fn_var <- hoistExpr (fsLit "fn") (mkLams args body) DontInline + zipf <- zipScalars arg_tys res_ty + clo <- scalarClosure arg_tys res_ty (Var fn_var) + (zipf `App` Var fn_var) + clo_var <- hoistExpr (fsLit "clo") clo DontInline + lclo <- liftPD (Var clo_var) + return (Var clo_var, lclo) + where + arg_tys = map idType args + res_ty = exprType body - let env_ty = cenv_vty info + is_scalar_ty ty + | Just (tycon, []) <- splitTyConApp_maybe ty + = tycon == intTyCon + || tycon == floatTyCon + || tycon == doubleTyCon - pa_dict <- paDictOfType env_ty + | otherwise = False - arg_ty <- vectType (varType bndr) - res_ty <- vectType (exprType $ deAnnotate body) + is_scalar vs (Var v) = v `elemVarSet` vs + is_scalar _ e@(Lit _) = is_scalar_ty $ exprType e + is_scalar vs (App e1 e2) = is_scalar vs e1 && is_scalar vs e2 + is_scalar _ _ = False - -- FIXME: move the functions to the top level - mono_vfn <- applyToTypes (Var vfn_var) (map TyVarTy tyvars) - mono_lfn <- applyToTypes (Var lfn_var) (map TyVarTy tyvars) + -- A scalar function has to actually compute something. Without the check, + -- we would treat (\(x :: Int) -> x) as a scalar function and lift it to + -- (map (\x -> x)) which is very bad. Normal lifting transforms it to + -- (\n# x -> x) which is what we want. + uses funs (Var v) = v `elemVarSet` funs + uses funs (App e1 e2) = uses funs e1 || uses funs e2 + uses _ _ = False - mk_clo <- builtin mkClosureVar - mk_cloP <- builtin mkClosurePVar - let vclo = Var mk_clo `mkTyApps` [arg_ty, res_ty, env_ty] - `mkApps` [pa_dict, mono_vfn, mono_lfn, venv] - - lclo = Var mk_cloP `mkTyApps` [arg_ty, res_ty, env_ty] - `mkApps` [pa_dict, mono_vfn, mono_lfn, lenv] +vectLam + :: Bool -- ^ When the RHS of a binding, whether that binding should be inlined. + -> Bool -- ^ Whether the binding is a loop breaker. + -> VarSet -- ^ The free variables in the body. + -> [Var] -- + -> CoreExprWithFVs + -> VM VExpr - return (vclo, lclo) - +vectLam inline loop_breaker fvs bs body + = dtrace (vcat [ text "vectLam " + , text "free vars = " <> ppr fvs + , text "binding vars = " <> ppr bs + , text "body = " <> ppr (deAnnotate body)]) -data CEnvInfo = CEnvInfo { - cenv_vars :: [Var] - , cenv_values :: [(CoreExpr, CoreExpr)] - , cenv_vty :: Type - , cenv_lty :: Type - , cenv_repr_tycon :: TyCon - , cenv_repr_tyargs :: [Type] - , cenv_repr_datacon :: DataCon - } + $ do tyvars <- localTyVars + (vs, vvs) <- readLEnv $ \env -> + unzip [(var, vv) | var <- varSetElems fvs + , Just vv <- [lookupVarEnv (local_vars env) var]] -mkCEnvInfo :: VarSet -> Var -> CoreExprWithFVs -> VM CEnvInfo -mkCEnvInfo fvs arg body - = do - locals <- readLEnv local_vars - let - (vars, vals) = unzip - [(var, val) | var <- varSetElems fvs - , Just val <- [lookupVarEnv locals var]] - vtys <- mapM (vectType . varType) vars - - (vty, repr_tycon, repr_tyargs, repr_datacon) <- mk_env_ty vtys - lty <- mkPArrayType vty - - return $ CEnvInfo { - cenv_vars = vars - , cenv_values = vals - , cenv_vty = vty - , cenv_lty = lty - , cenv_repr_tycon = repr_tycon - , cenv_repr_tyargs = repr_tyargs - , cenv_repr_datacon = repr_datacon - } - where - mk_env_ty [vty] - = return (vty, error "absent cinfo_repr_tycon" - , error "absent cinfo_repr_tyargs" - , error "absent cinfo_repr_datacon") + arg_tys <- mapM (vectType . idType) bs - mk_env_ty vtys - = do - let ty = mkCoreTupTy vtys - (repr_tc, repr_tyargs) <- lookupPArrayFamInst ty - let [repr_con] = tyConDataCons repr_tc - return (ty, repr_tc, repr_tyargs, repr_con) + dtrace (text "arg_tys = " <> ppr arg_tys) $ return () - + res_ty <- vectType (exprType $ deAnnotate body) -mkClosureEnvs :: CEnvInfo -> CoreExpr -> (CoreExpr, CoreExpr) -mkClosureEnvs info lc - | [] <- vals - = (Var unitDataConId, mkApps (Var $ dataConWrapId (cenv_repr_datacon info)) - [lc, Var unitDataConId]) + dtrace (text "res_ty = " <> ppr res_ty) $ return () - | [(vval, lval)] <- vals - = (vval, lval) + buildClosures tyvars vvs arg_tys res_ty + . hoistPolyVExpr tyvars (maybe_inline (length vs + length bs)) + $ do + lc <- builtin liftingContext + (vbndrs, vbody) <- vectBndrsIn (vs ++ bs) (vectExpr body) - | otherwise - = (mkCoreTup vvals, Var (dataConWrapId $ cenv_repr_datacon info) - `mkTyApps` cenv_repr_tyargs info - `mkApps` (lc : lvals)) + dtrace (text "vbody = " <> ppr vbody) $ return () + vbody' <- break_loop lc res_ty vbody + return $ vLams lc vbndrs vbody' where - vals = cenv_values info - (vvals, lvals) = unzip vals - -mkClosureFns :: CEnvInfo -> [TyVar] -> Var -> CoreExprWithFVs - -> VM (CoreExpr, CoreExpr) -mkClosureFns info tyvars arg body - = closedV - . abstractOverTyVars tyvars - $ \mk_tlams -> - do - (vfn, lfn) <- mkClosureMonoFns info arg body - return (mk_tlams vfn, mk_tlams lfn) - -mkClosureMonoFns :: CEnvInfo -> Var -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr) -mkClosureMonoFns info arg body + maybe_inline n | inline = Inline n + | otherwise = DontInline + + break_loop lc ty (ve, le) + | loop_breaker + = do + empty <- emptyPD ty + lty <- mkPDataType ty + return (ve, mkWildCase (Var lc) intPrimTy lty + [(DEFAULT, [], le), + (LitAlt (mkMachInt 0), [], empty)]) + + | otherwise = return (ve, le) + + +vectTyAppExpr :: CoreExprWithFVs -> [Type] -> VM VExpr +vectTyAppExpr (_, AnnVar v) tys = vectPolyVar v tys +vectTyAppExpr e tys = cantVectorise "Can't vectorise expression" + (ppr $ deAnnotate e `mkTyApps` tys) + +-- We convert +-- +-- case e :: t of v { ... } +-- +-- to +-- +-- V: let v' = e in case v' of _ { ... } +-- L: let v' = e in case v' `cast` ... of _ { ... } +-- +-- When lifting, we have to do it this way because v must have the type +-- [:V(T):] but the scrutinee must be cast to the representation type. We also +-- have to handle the case where v is a wild var correctly. +-- + +-- FIXME: this is too lazy +vectAlgCase :: TyCon -> [Type] -> CoreExprWithFVs -> Var -> Type + -> [(AltCon, [Var], CoreExprWithFVs)] + -> VM VExpr +vectAlgCase _tycon _ty_args scrut bndr ty [(DEFAULT, [], body)] = do - lc_bndr <- newLocalVar FSLIT("lc") intTy - (varg : vbndrs, larg : lbndrs, (vbody, lbody)) - <- vectBndrsIn (arg : cenv_vars info) - (vectExpr (Var lc_bndr) body) + vscrut <- vectExpr scrut + (vty, lty) <- vectAndLiftType ty + (vbndr, vbody) <- vectBndrIn bndr (vectExpr body) + return $ vCaseDEFAULT vscrut vbndr vty lty vbody - venv_bndr <- newLocalVar FSLIT("env") vty - lenv_bndr <- newLocalVar FSLIT("env") lty +vectAlgCase _tycon _ty_args scrut bndr ty [(DataAlt _, [], body)] + = do + vscrut <- vectExpr scrut + (vty, lty) <- vectAndLiftType ty + (vbndr, vbody) <- vectBndrIn bndr (vectExpr body) + return $ vCaseDEFAULT vscrut vbndr vty lty vbody - let vcase = bind_venv (Var venv_bndr) vbody vbndrs - lcase <- bind_lenv (Var lenv_bndr) lbody lc_bndr lbndrs - return (mkLams [venv_bndr, varg] vcase, mkLams [lenv_bndr, larg] lcase) +vectAlgCase _tycon _ty_args scrut bndr ty [(DataAlt dc, bndrs, body)] + = do + (vty, lty) <- vectAndLiftType ty + vexpr <- vectExpr scrut + (vbndr, (vbndrs, (vect_body, lift_body))) + <- vect_scrut_bndr + . vectBndrsIn bndrs + $ vectExpr body + let (vect_bndrs, lift_bndrs) = unzip vbndrs + (vscrut, lscrut, pdata_tc, _arg_tys) <- mkVScrut (vVar vbndr) + vect_dc <- maybeV (lookupDataCon dc) + let [pdata_dc] = tyConDataCons pdata_tc + + let vcase = mk_wild_case vscrut vty vect_dc vect_bndrs vect_body + lcase = mk_wild_case lscrut lty pdata_dc lift_bndrs lift_body + + return $ vLet (vNonRec vbndr vexpr) (vcase, lcase) where - vty = cenv_vty info - lty = cenv_lty info + vect_scrut_bndr | isDeadBinder bndr = vectBndrNewIn bndr (fsLit "scrut") + | otherwise = vectBndrIn bndr - arity = length (cenv_vars info) + mk_wild_case expr ty dc bndrs body + = mkWildCase expr (exprType expr) ty [(DataAlt dc, bndrs, body)] - bind_venv venv vbody [] = vbody - bind_venv venv vbody [vbndr] = Let (NonRec vbndr venv) vbody - bind_venv venv vbody vbndrs - = Case venv (mkWildId vty) (exprType vbody) - [(DataAlt (tupleCon Boxed arity), vbndrs, vbody)] +vectAlgCase tycon _ty_args scrut bndr ty alts + = do + vect_tc <- maybeV (lookupTyCon tycon) + (vty, lty) <- vectAndLiftType ty - bind_lenv lenv lbody lc_bndr [lbndr] - = do - lengthPA <- builtin lengthPAVar - return . Let (NonRec lbndr lenv) - $ Case (mkApps (Var lengthPA) [Type vty, (Var lbndr)]) - lc_bndr - intTy - [(DEFAULT, [], lbody)] - - bind_lenv lenv lbody lc_bndr lbndrs - = return - $ Case (unwrapFamInstScrut (cenv_repr_tycon info) - (cenv_repr_tyargs info) - lenv) - (mkWildId lty) - (exprType lbody) - [(DataAlt (cenv_repr_datacon info), lc_bndr : lbndrs, lbody)] - -vectTyAppExpr :: CoreExpr -> CoreExprWithFVs -> [Type] -> VM (CoreExpr, CoreExpr) -vectTyAppExpr lc (_, AnnVar v) tys = vectPolyVar lc v tys -vectTyAppExpr lc e tys = pprPanic "vectTyAppExpr" (ppr $ deAnnotate e) + let arity = length (tyConDataCons vect_tc) + sel_ty <- builtin (selTy arity) + sel_bndr <- newLocalVar (fsLit "sel") sel_ty + let sel = Var sel_bndr --- ---------------------------------------------------------------------------- --- Types - -vectTyCon :: TyCon -> VM TyCon -vectTyCon tc - | isFunTyCon tc = builtin closureTyCon - | isBoxedTupleTyCon tc = return tc - | isUnLiftedTyCon tc = return tc - | otherwise = do - r <- lookupTyCon tc - case r of - Just tc' -> return tc' - - -- FIXME: just for now - Nothing -> pprTrace "ccTyCon:" (ppr tc) $ return tc - -vectType :: Type -> VM Type -vectType ty | Just ty' <- coreView ty = vectType ty -vectType (TyVarTy tv) = return $ TyVarTy tv -vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2) -vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys) -vectType (FunTy ty1 ty2) = liftM2 TyConApp (builtin closureTyCon) - (mapM vectType [ty1,ty2]) -vectType (ForAllTy tv ty) - = do - r <- paDictArgType tv - ty' <- vectType ty - return $ ForAllTy tv (wrap r ty') + (vbndr, valts) <- vect_scrut_bndr + $ mapM (proc_alt arity sel vty lty) alts' + let (vect_dcs, vect_bndrss, lift_bndrss, vbodies) = unzip4 valts + + vexpr <- vectExpr scrut + (vect_scrut, lift_scrut, pdata_tc, _arg_tys) <- mkVScrut (vVar vbndr) + let [pdata_dc] = tyConDataCons pdata_tc + + let (vect_bodies, lift_bodies) = unzip vbodies + + vdummy <- newDummyVar (exprType vect_scrut) + ldummy <- newDummyVar (exprType lift_scrut) + let vect_case = Case vect_scrut vdummy vty + (zipWith3 mk_vect_alt vect_dcs vect_bndrss vect_bodies) + + lc <- builtin liftingContext + lbody <- combinePD vty (Var lc) sel lift_bodies + let lift_case = Case lift_scrut ldummy lty + [(DataAlt pdata_dc, sel_bndr : concat lift_bndrss, + lbody)] + + return . vLet (vNonRec vbndr vexpr) + $ (vect_case, lift_case) where - wrap Nothing = id - wrap (Just pa_ty) = FunTy pa_ty + vect_scrut_bndr | isDeadBinder bndr = vectBndrNewIn bndr (fsLit "scrut") + | otherwise = vectBndrIn bndr -vectType ty = pprPanic "vectType:" (ppr ty) + alts' = sortBy (\(alt1, _, _) (alt2, _, _) -> cmp alt1 alt2) alts + + cmp (DataAlt dc1) (DataAlt dc2) = dataConTag dc1 `compare` dataConTag dc2 + cmp DEFAULT DEFAULT = EQ + cmp DEFAULT _ = LT + cmp _ DEFAULT = GT + cmp _ _ = panic "vectAlgCase/cmp" + + proc_alt arity sel _ lty (DataAlt dc, bndrs, body) + = do + vect_dc <- maybeV (lookupDataCon dc) + let ntag = dataConTagZ vect_dc + tag = mkDataConTag vect_dc + fvs = freeVarsOf body `delVarSetList` bndrs + + sel_tags <- liftM (`App` sel) (builtin (selTags arity)) + lc <- builtin liftingContext + elems <- builtin (selElements arity ntag) + + (vbndrs, vbody) + <- vectBndrsIn bndrs + . localV + $ do + binds <- mapM (pack_var (Var lc) sel_tags tag) + . filter isLocalId + $ varSetElems fvs + (ve, le) <- vectExpr body + return (ve, Case (elems `App` sel) lc lty + [(DEFAULT, [], (mkLets (concat binds) le))]) + -- empty <- emptyPD vty + -- return (ve, Case (elems `App` sel) lc lty + -- [(DEFAULT, [], Let (NonRec flags_var flags_expr) + -- $ mkLets (concat binds) le), + -- (LitAlt (mkMachInt 0), [], empty)]) + let (vect_bndrs, lift_bndrs) = unzip vbndrs + return (vect_dc, vect_bndrs, lift_bndrs, vbody) + + proc_alt _ _ _ _ _ = panic "vectAlgCase/proc_alt" + + mk_vect_alt vect_dc bndrs body = (DataAlt vect_dc, bndrs, body) + + pack_var len tags t v + = do + r <- lookupVar v + case r of + Local (vv, lv) -> + do + lv' <- cloneVar lv + expr <- packByTagPD (idType vv) (Var lv) len tags t + updLEnv (\env -> env { local_vars = extendVarEnv + (local_vars env) v (vv, lv') }) + return [(NonRec lv' expr)] + + _ -> return []