X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fvectorise%2FVectorise.hs;h=4994e3f1659cbd1d333bba333ba07587f6f2219d;hp=70e69b7e90a0386742baad289a214ccee71ad962;hb=febf1ced754a3996ac1a5877dcded87828560d1c;hpb=cc67e20f5c6355919b54f82c2620515fa28269a8 diff --git a/compiler/vectorise/Vectorise.hs b/compiler/vectorise/Vectorise.hs index 70e69b7..4994e3f 100644 --- a/compiler/vectorise/Vectorise.hs +++ b/compiler/vectorise/Vectorise.hs @@ -1,468 +1,269 @@ +{-# OPTIONS -fno-warn-missing-signatures -fno-warn-unused-do-bind #-} -module Vectorise( vectorise ) +module Vectorise ( vectorise ) where -import VectMonad -import VectUtils -import VectType -import VectCore +import Vectorise.Type.Env +import Vectorise.Type.Type +import Vectorise.Convert +import Vectorise.Utils.Hoisting +import Vectorise.Exp +import Vectorise.Vect +import Vectorise.Env +import Vectorise.Monad -import DynFlags import HscTypes hiding ( MonadThings(..) ) - -import Module ( dphSeqPackageId, dphParPackageId ) -import CoreLint ( showPass, endPass ) -import CoreSyn -import CoreUtils +import CoreUnfold ( mkInlineUnfolding ) import CoreFVs -import SimplMonad ( SimplCount, zeroSimplCount ) -import Rules ( RuleBase ) -import DataCon -import TyCon +import PprCore +import CoreSyn +import CoreMonad ( CoreM, getHscEnv ) import Type -import FamInstEnv ( extendFamInstEnvList ) -import Var -import VarEnv -import VarSet import Id import OccName +import DynFlags +import BasicTypes ( isLoopBreaker ) +import Outputable +import Util ( zipLazy ) +import MonadUtils -import DsMonad +import Control.Monad -import Literal ( Literal, mkMachInt ) -import TysWiredIn -import Outputable -import FastString -import Control.Monad ( liftM, liftM2, zipWithM ) -import Data.List ( sortBy, unzip4 ) +-- | Vectorise a single module. +-- +vectorise :: ModGuts -> CoreM ModGuts +vectorise guts + = do { hsc_env <- getHscEnv + ; liftIO $ vectoriseIO hsc_env guts + } -vectorise :: DPHBackend -> HscEnv -> UniqSupply -> RuleBase -> ModGuts - -> IO (SimplCount, ModGuts) -vectorise backend hsc_env _ _ guts - = do - showPass dflags "Vectorisation" - eps <- hscEPS hsc_env - let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps - Just (info', guts') <- initV (backendPackage backend) hsc_env guts info - (vectModule guts) - endPass dflags "Vectorisation" Opt_D_dump_vect (mg_binds guts') - return (zeroSimplCount dflags, guts' { mg_vect_info = info' }) - where - dflags = hsc_dflags hsc_env +-- | Vectorise a single monad, given the dynamic compiler flags and HscEnv. +-- +vectoriseIO :: HscEnv -> ModGuts -> IO ModGuts +vectoriseIO hsc_env guts + = do { -- Get information about currently loaded external packages. + ; eps <- hscEPS hsc_env - backendPackage DPHSeq = dphSeqPackageId - backendPackage DPHPar = dphParPackageId + -- Combine vectorisation info from the current module, and external ones. + ; let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps -vectModule :: ModGuts -> VM ModGuts -vectModule guts - = do - (types', fam_insts, tc_binds) <- vectTypeEnv (mg_types guts) + -- Run the main VM computation. + ; Just (info', guts') <- initV hsc_env guts info (vectModule guts) + ; return (guts' { mg_vect_info = info' }) + } - let fam_inst_env' = extendFamInstEnvList (mg_fam_inst_env guts) fam_insts - updGEnv (setFamInstEnv fam_inst_env') +-- | Vectorise a single module, in the VM monad. +-- +vectModule :: ModGuts -> VM ModGuts +vectModule guts@(ModGuts { mg_types = types + , mg_binds = binds + , mg_fam_insts = fam_insts + }) + = do { dumpOptVt Opt_D_dump_vt_trace "Before vectorisation" $ + pprCoreBindings binds + + -- Vectorise the type environment. + -- This may add new TyCons and DataCons. + ; (types', new_fam_insts, tc_binds) <- vectTypeEnv types + + ; (_, fam_inst_env) <- readGEnv global_fam_inst_env -- dicts <- mapM buildPADict pa_insts -- workers <- mapM vectDataConWorkers pa_insts - 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 - } + -- Vectorise all the top level bindings. + ; binds' <- mapM vectTopBind binds + + ; return $ guts { mg_types = types' + , mg_binds = Rec tc_binds : binds' + , mg_fam_inst_env = fam_inst_env + , mg_fam_insts = fam_insts ++ new_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 - var' <- vectTopBinder var - expr' <- vectTopRhs var expr - hs <- takeHoisted - cexpr <- tryConvert var var' expr - return . Rec $ (var, cexpr) : (var', expr') : hs + = do { -- Vectorise the right-hand side, create an appropriate top-level binding and add it to + -- the vectorisation map. + ; (inline, isScalar, expr') <- vectTopRhs [] var expr + ; var' <- vectTopBinder var inline expr' + ; when isScalar $ + addGlobalScalar var + + -- We replace the original top-level binding by a value projected from the vectorised + -- closure and add any newly created hoisted top-level bindings. + ; cexpr <- tryConvert var var' expr + ; hs <- takeHoisted + ; return . Rec $ (var, cexpr) : (var', expr') : hs + } `orElseV` return b - vectTopBind b@(Rec bs) - = do - vars' <- mapM vectTopBinder vars - exprs' <- zipWithM vectTopRhs vars exprs - hs <- takeHoisted - cexprs <- sequence $ zipWith3 tryConvert vars vars' exprs - return . Rec $ zip vars cexprs ++ zip vars' exprs' ++ hs + = let (vars, exprs) = unzip bs + in + do { (vars', _, exprs', hs) <- fixV $ + \ ~(_, inlines, rhss, _) -> + do { -- Vectorise the right-hand sides, create an appropriate top-level bindings and + -- add them to the vectorisation map. + ; vars' <- sequence [vectTopBinder var inline rhs + | (var, ~(inline, rhs)) <- zipLazy vars (zip inlines rhss)] + ; (inlines, areScalars, exprs') <- mapAndUnzip3M (uncurry $ vectTopRhs vars) bs + ; hs <- takeHoisted + ; if and areScalars + then -- (1) Entire recursive group is scalar + -- => add all variables to the global set of scalars + do { mapM addGlobalScalar vars + ; return (vars', inlines, exprs', hs) + } + else -- (2) At least one binding is not scalar + -- => vectorise again with empty set of local scalars + do { (inlines, _, exprs') <- mapAndUnzip3M (uncurry $ vectTopRhs []) bs + ; hs <- takeHoisted + ; return (vars', inlines, exprs', hs) + } + } + + -- Replace the original top-level bindings by a values projected from the vectorised + -- closures and add any newly created hoisted top-level bindings to the group. + ; cexprs <- sequence $ zipWith3 tryConvert vars vars' exprs + ; return . Rec $ zip vars cexprs ++ zip vars' exprs' ++ hs + } `orElseV` - return b - where - (vars, exprs) = unzip bs - -vectTopBinder :: Var -> VM Var -vectTopBinder var - = do - vty <- vectType (idType var) - var' <- cloneId mkVectOcc var vty - defGlobalVar var var' - return var' - -vectTopRhs :: Var -> CoreExpr -> VM CoreExpr -vectTopRhs var expr - = do - closedV . liftM vectorised - . inBind var - $ vectPolyExpr (freeVars expr) - -tryConvert :: Var -> Var -> CoreExpr -> VM CoreExpr -tryConvert var vect_var rhs - = fromVect (idType var) (Var vect_var) `orElseV` return rhs - --- ---------------------------------------------------------------------------- --- Bindings - -vectBndr :: Var -> VM VVar -vectBndr v - = do - (vty, lty) <- vectAndLiftType (idType v) - let vv = v `Id.setIdType` vty - lv = v `Id.setIdType` lty - updLEnv (mapTo vv lv) - return (vv, lv) - where - mapTo vv lv env = env { local_vars = extendVarEnv (local_vars env) v (vv, lv) } - -vectBndrNew :: Var -> FastString -> VM VVar -vectBndrNew v fs - = do - vty <- vectType (idType v) - vv <- newLocalVVar fs vty - updLEnv (upd vv) - return vv - where - upd vv env = env { local_vars = extendVarEnv (local_vars env) v vv } - -vectBndrIn :: Var -> VM a -> VM (VVar, a) -vectBndrIn v p - = localV - $ do - vv <- vectBndr v - x <- p - return (vv, x) - -vectBndrNewIn :: Var -> FastString -> VM a -> VM (VVar, a) -vectBndrNewIn v fs p - = localV - $ do - vv <- vectBndrNew v fs - x <- p - return (vv, x) - -vectBndrsIn :: [Var] -> VM a -> VM ([VVar], a) -vectBndrsIn vs p - = localV - $ do - vvs <- mapM vectBndr vs - x <- p - return (vvs, x) - --- ---------------------------------------------------------------------------- --- Expressions - -vectVar :: Var -> VM VExpr -vectVar v - = do - r <- lookupVar v - case r of - Local (vv,lv) -> return (Var vv, Var lv) - Global vv -> do - let vexpr = Var vv - lexpr <- liftPA vexpr - return (vexpr, lexpr) - -vectPolyVar :: Var -> [Type] -> VM VExpr -vectPolyVar v tys - = do - vtys <- mapM vectType tys - r <- lookupVar v - case r of - Local (vv, lv) -> liftM2 (,) (polyApply (Var vv) vtys) - (polyApply (Var lv) vtys) - Global poly -> do - vexpr <- polyApply (Var poly) vtys - lexpr <- liftPA vexpr - return (vexpr, lexpr) - -vectLiteral :: Literal -> VM VExpr -vectLiteral lit - = do - lexpr <- liftPA (Lit lit) - return (Lit lit, lexpr) - -vectPolyExpr :: CoreExprWithFVs -> VM VExpr -vectPolyExpr (_, AnnNote note expr) - = liftM (vNote note) $ vectPolyExpr expr -vectPolyExpr expr - = polyAbstract tvs $ \abstract -> - do - mono' <- vectExpr mono - return $ mapVect abstract mono' - where - (tvs, mono) = collectAnnTypeBinders expr - -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 - (fn, tys) = collectAnnTypeArgs e - -vectExpr (_, AnnApp (_, AnnVar v) (_, AnnLit lit)) - | Just con <- isDataConId_maybe v - , is_special_con con - = do - let vexpr = App (Var v) (Lit lit) - lexpr <- liftPA vexpr - return (vexpr, lexpr) - where - is_special_con con = con `elem` [intDataCon, floatDataCon, doubleDataCon] - - -vectExpr (_, AnnApp fn arg) - = do - arg_ty' <- vectType arg_ty - res_ty' <- vectType res_ty - fn' <- vectExpr fn - arg' <- vectExpr arg - mkClosureApp arg_ty' res_ty' fn' arg' - where - (arg_ty, res_ty) = splitFunTy . exprType $ deAnnotate fn - -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 (_, AnnLet (AnnNonRec bndr rhs) body) - = do - vrhs <- localV . inBind bndr $ vectPolyExpr rhs - (vbndr, vbody) <- vectBndrIn bndr (vectExpr body) - return $ vLet (vNonRec vbndr vrhs) vbody - -vectExpr (_, AnnLet (AnnRec bs) body) - = do - (vbndrs, (vrhss, vbody)) <- vectBndrsIn bndrs - $ liftM2 (,) - (zipWithM vect_rhs bndrs rhss) - (vectPolyExpr body) - return $ vLet (vRec vbndrs vrhss) vbody - where - (bndrs, rhss) = unzip bs - - vect_rhs bndr rhs = localV - . inBind bndr - $ vectExpr rhs - -vectExpr e@(fvs, AnnLam bndr _) - | isId bndr = vectLam fvs bs body - where - (bs,body) = collectAnnValBinders e - -vectExpr e = traceNoV "vectExpr: can't vectorise" (ppr $ deAnnotate e) - -vectLam :: VarSet -> [Var] -> CoreExprWithFVs -> VM VExpr -vectLam fvs bs body - = do - tyvars <- localTyVars - (vs, vvs) <- readLEnv $ \env -> - unzip [(var, vv) | var <- varSetElems fvs - , Just vv <- [lookupVarEnv (local_vars env) var]] - - arg_tys <- mapM (vectType . idType) bs - res_ty <- vectType (exprType $ deAnnotate body) - - buildClosures tyvars vvs arg_tys res_ty - . hoistPolyVExpr tyvars - $ do - lc <- builtin liftingContext - (vbndrs, vbody) <- vectBndrsIn (vs ++ bs) - (vectExpr body) - return $ vLams lc vbndrs vbody - -vectTyAppExpr :: CoreExprWithFVs -> [Type] -> VM VExpr -vectTyAppExpr (_, AnnVar v) tys = vectPolyVar v tys -vectTyAppExpr e _ = traceNoV "vectTyAppExpr: can't vectorise" (ppr $ deAnnotate e) - --- We convert + return b + +-- | 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@ -- --- case e :: t of v { ... } +-- NOTE: vectTopBinder *MUST* be lazy in inline and expr because of how it is +-- used inside of fixV in vectTopBind -- --- to +vectTopBinder :: Var -- ^ Name of the binding. + -> Inline -- ^ Whether it should be inlined, used to annotate it. + -> CoreExpr -- ^ RHS of 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) + + -- If there is a vectorisation declartion for this binding, make sure that its type + -- matches + ; vectDecl <- lookupVectDecl var + ; case vectDecl of + Nothing -> return () + Just (vdty, _) + | eqType vty vdty -> return () + | otherwise -> + cantVectorise ("Type mismatch in vectorisation pragma for " ++ show var) $ + (text "Expected type" <+> ppr vty) + $$ + (text "Inferred type" <+> ppr vdty) + + -- Make the vectorised version of binding's name, and set the unfolding used for inlining + ; var' <- liftM (`setIdUnfoldingLazily` 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 -> mkInlineUnfolding (Just arity) expr + DontInline -> noUnfolding + +-- | Vectorise the RHS of a top-level binding, in an empty local environment. -- --- V: let v' = e in case v' of _ { ... } --- L: let v' = e in case v' `cast` ... of _ { ... } +-- We need to distinguish three cases: -- --- 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. +-- (1) We have a (non-scalar) vectorisation declaration for the variable (which explicitly provides +-- vectorised code implemented by the user) +-- => no automatic vectorisation & instead use the user-supplied code +-- +-- (2) We have a scalar vectorisation declaration for the variable +-- => generate vectorised code that uses a scalar 'map'/'zipWith' to lift the computation +-- +-- (3) There is no vectorisation declaration for the variable +-- => perform automatic vectorisation of the RHS -- - --- 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 - vscrut <- vectExpr scrut - (vty, lty) <- vectAndLiftType ty - (vbndr, vbody) <- vectBndrIn bndr (vectExpr body) - return $ vCaseDEFAULT vscrut vbndr vty lty vbody - -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 - -vectAlgCase tycon _ty_args scrut bndr ty [(DataAlt dc, bndrs, body)] - = do - vect_tc <- maybeV (lookupTyCon tycon) - (vty, lty) <- vectAndLiftType ty - vexpr <- vectExpr scrut - (vbndr, (vbndrs, vbody)) <- vect_scrut_bndr - . vectBndrsIn bndrs - $ vectExpr body - - (vscrut, arr_tc, _arg_tys) <- mkVScrut (vVar vbndr) - vect_dc <- maybeV (lookupDataCon dc) - let [arr_dc] = tyConDataCons arr_tc - repr <- mkRepr vect_tc - shape_bndrs <- arrShapeVars repr - return . vLet (vNonRec vbndr vexpr) - $ vCaseProd vscrut vty lty vect_dc arr_dc shape_bndrs vbndrs vbody - where - vect_scrut_bndr | isDeadBinder bndr = vectBndrNewIn bndr (fsLit "scrut") - | otherwise = vectBndrIn bndr - -vectAlgCase tycon _ty_args scrut bndr ty alts - = do - vect_tc <- maybeV (lookupTyCon tycon) - (vty, lty) <- vectAndLiftType ty - repr <- mkRepr vect_tc - shape_bndrs <- arrShapeVars repr - (len, sel, indices) <- arrSelector repr (map Var shape_bndrs) - - (vbndr, valts) <- vect_scrut_bndr $ mapM (proc_alt sel vty lty) alts' - let (vect_dcs, vect_bndrss, lift_bndrss, vbodies) = unzip4 valts - - vexpr <- vectExpr scrut - (vscrut, arr_tc, _arg_tys) <- mkVScrut (vVar vbndr) - let [arr_dc] = tyConDataCons arr_tc - - let (vect_scrut, lift_scrut) = vscrut - (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) - - lbody <- combinePA vty len sel indices lift_bodies - let lift_case = Case lift_scrut ldummy lty - [(DataAlt arr_dc, shape_bndrs ++ concat lift_bndrss, - lbody)] - - return . vLet (vNonRec vbndr vexpr) - $ (vect_case, lift_case) - where - vect_scrut_bndr | isDeadBinder bndr = vectBndrNewIn bndr (fsLit "scrut") - | otherwise = vectBndrIn bndr - - 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 sel vty lty (DataAlt dc, bndrs, body) - = do - vect_dc <- maybeV (lookupDataCon dc) - let tag = mkDataConTag vect_dc - fvs = freeVarsOf body `delVarSetList` bndrs - (vect_bndrs, lift_bndrs, vbody) - <- vect_alt_bndrs bndrs - $ \len -> packLiftingContext len sel tag fvs vty lty - $ vectExpr body - - return (vect_dc, vect_bndrs, lift_bndrs, vbody) - proc_alt _ _ _ _ = panic "vectAlgCase/proc_alt" - - vect_alt_bndrs [] p - = do - void_tc <- builtin voidTyCon - let void_ty = mkTyConApp void_tc [] - arr_ty <- mkPArrayType void_ty - bndr <- newLocalVar (fsLit "voids") arr_ty - len <- lengthPA void_ty (Var bndr) - e <- p len - return ([], [bndr], e) - - vect_alt_bndrs bndrs p - = localV - $ do - vbndrs <- mapM vectBndr bndrs - let (vect_bndrs, lift_bndrs) = unzip vbndrs - vv : _ = vect_bndrs - lv : _ = lift_bndrs - len <- lengthPA (idType vv) (Var lv) - e <- p len - return (vect_bndrs, lift_bndrs, e) - - mk_vect_alt vect_dc bndrs body = (DataAlt vect_dc, bndrs, body) - -packLiftingContext :: CoreExpr -> CoreExpr -> CoreExpr -> VarSet - -> Type -> Type -> VM VExpr -> VM VExpr -packLiftingContext len shape tag fvs vty lty p - = do - select <- builtin selectPAIntPrimVar - let sel_expr = mkApps (Var select) [shape, tag] - sel_var <- newLocalVar (fsLit "sel#") (exprType sel_expr) - lc_var <- builtin liftingContext - localV $ - do - bnds <- mapM (packFreeVar (Var lc_var) (Var sel_var)) - . filter isLocalId - $ varSetElems fvs - (vexpr, lexpr) <- p - empty <- emptyPA vty - return (vexpr, Let (NonRec sel_var sel_expr) - $ Case len lc_var lty - [(DEFAULT, [], mkLets (concat bnds) lexpr), - (LitAlt (mkMachInt 0), [], empty)]) - -packFreeVar :: CoreExpr -> CoreExpr -> Var -> VM [CoreBind] -packFreeVar len sel v - = do - r <- lookupVar v - case r of - Local (vv,lv) -> - do - lv' <- cloneVar lv - expr <- packPA (idType vv) (Var lv) len sel - updLEnv (upd vv lv') - return [(NonRec lv' expr)] - - _ -> return [] +vectTopRhs :: [Var] -- ^ Names of all functions in the rec block + -> Var -- ^ Name of the binding. + -> CoreExpr -- ^ Body of the binding. + -> VM ( Inline -- (1) inline specification for the binding + , Bool -- (2) whether the right-hand side is a scalar computation + , CoreExpr) -- (3) the vectorised right-hand side +vectTopRhs recFs var expr + = closedV + $ do { traceVt ("vectTopRhs of " ++ show var) $ ppr expr + + ; globalScalar <- isGlobalScalar var + ; vectDecl <- lookupVectDecl var + ; rhs globalScalar vectDecl + } where - upd vv lv' env = env { local_vars = extendVarEnv (local_vars env) v (vv, lv') } - + rhs _globalScalar (Just (_, expr')) -- Case (1) + = return (inlineMe, False, expr') + rhs True Nothing -- Case (2) + = do { expr' <- vectScalarFun True recFs expr + ; return (inlineMe, True, vectorised expr') + } + rhs False Nothing -- Case (3) + = do { let fvs = freeVars expr + ; (inline, isScalar, vexpr) <- inBind var $ + vectPolyExpr (isLoopBreaker $ idOccInfo var) recFs fvs + ; return (inline, isScalar, vectorised vexpr) + } + +-- | Project out the vectorised version of a binding from some closure, +-- or return the original body if that doesn't work or the binding is scalar. +-- +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 + = do { globalScalar <- isGlobalScalar var + ; if globalScalar + then + return rhs + else + fromVect (idType var) (Var vect_var) `orElseV` return rhs + }